目標
程式中可選擇使用「舊」或「新」加解密。
application.yml 等組態同時支援兩種加密字串（便於平滑換代）。
A. 程式碼中手動加解密：用 @Qualifier 注入兩個 Encryptor
定義兩個 StringEncryptor Bean：
legacyEncryptor：對應你原本的 PBEWithMD5AndDES + NoIv + 固定密碼。
encryptorBean：協力商那組 PBEWithHmacSHA512AndAES_256 + RandomIv + 動態 salt。
@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;
}
// 新：協力商版（安全組態）
@Bean("encryptorBean")
public StringEncryptor encryptorBean() {
String p1 = System.getProperty("P_ENV_1");
String p2 = System.getProperty("P_ENV_2");
if (org.apache.commons.lang3.StringUtils.isBlank(p1)
|| org.apache.commons.lang3.StringUtils.isBlank(p2)
|| "null".equalsIgnoreCase(p1)
|| "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;
}
}
使用時用 @Qualifier 指定：
@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. 組態屬性的自動解密：用「路由型」Encryptor + 多前綴
ulisesbocchio/jasypt-spring-boot 預設一次只能指定一個 jasypt.encryptor.bean 來處理組態的 ENC(...)。若你要同時支援「舊」與「新」兩種加密格式，有兩條路：
路線 1（推薦）：自訂前綴切換
定義不同前綴，例如：
新格式：ENC_NEW(...) → 用 encryptorBean
舊格式：ENC_OLD(...) → 用 legacyEncryptor
做法：提供自訂 Detector/Resolver 或一個路由型 Encryptor 配合自訂 Detector，讓它看前綴決定用哪個 encryptor。
@Configuration
public class JasyptRoutingConfig {
@Bean("routingEncryptor")
public StringEncryptor routingEncryptor(
@Qualifier("legacyEncryptor") StringEncryptor legacy,
@Qualifier("encryptorBean") StringEncryptor modern) {
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) { /* fall through */ }
return legacy.decrypt(encryptedMessage);
}
};
}
// 自訂前綴偵測：支援 ENC_NEW(...)、ENC_OLD(...)、也保留 ENC(...)
@Bean
public com.ulisesbocchio.jasyptspringboot.detector.EncryptablePropertyDetector encryptablePropertyDetector() {
return value -> {
if (value == null) return false;
return value.startsWith("ENC_NEW(") || value.startsWith("ENC_OLD(") || value.startsWith("ENC(");
};
}
@Bean
public com.ulisesbocchio.jasyptspringboot.resolver.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 指向這個「路由」能力（其實 Resolver 已經接手了，這行可以保留指向 routingEncryptor；或直接不設）：
jasypt:
encryptor:
bean: routingEncryptor
然後在組態檔裡你可以混用：
# 新格式（AES-256）
spring:
datasource:
password: "ENC_NEW(xxxxxxx...)"
# 舊格式（MD5+DES）
legacy:
token: "ENC_OLD(yyyyyyy...)"
# 未標記舊新者（歷史遺留）
other:
secret: "ENC(zzzzzz...)"
路線 2：只掛一個 jasypt.encryptor.bean
如果只在組態層面啟用新演算法（jasypt.encryptor.bean=encryptorBean），舊資料不再用於組態，就不需要路由。舊資料若還會在程式中用到，就改由程式碼的 @Qualifier("legacyEncryptor") 來解即可。這是最簡潔，但無法同時在組態屬性裡解兩種格式。
C. 產出與轉換策略（實務建議）
新資料一律用 AES-256（encryptorBean）產生；避免再寫入 MD5+DES。
舊資料保留解密能力一段時間（legacyEncryptor），逐步轉檔或於讀取時即時轉存為新格式。
把組態值改標記為 ENC_NEW(...)，僅在極端相容需求時才保留 ENC_OLD(...)。
D. 典型落坑提醒
你的原始片段有些小誤植：config. setPassword(sait)（應為 salt）、config-setAlgorithm（應為 setAlgorithm）、全形括號與空白等；上面提供的程式碼已修正。
PBEWithMD5AndDES + NoIvGenerator 安全性很弱，只作相容期使用，並避免再用於新密文。
P_ENV_1/P_ENV_2 來自 JVM 系統屬性或環境變數時，要考慮空/null，已在範例處理。
JCE AES-256 在舊 JDK 曾需「無限制強度策略檔」；現代 JDK 已內建，仍建議在所有環境驗證一次。
E. 最小可用配置總結
@Bean("legacyEncryptor") + @Bean("encryptorBean") 兩組都註冊。
組態層若需同時支援兩種格式：加上自訂 Detector/Resolver（或路由 Encryptor），並允許 ENC_NEW(...)、ENC_OLD(...)。
程式碼層用 @Qualifier 精準選擇要用哪一組。
接下來若你要，我可以產生一支小測試（JUnit 或簡單 main()）幫你把明文轉成 ENC_NEW(...) / ENC_OLD(...) 兩種密文，方便你替換組態。
目標



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



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



A. 程式碼中手動加解密：用 @Qualifier 注入兩個 Encryptor



定義兩個 StringEncryptor Bean：



legacyEncryptor：對應你原本的 PBEWithMD5AndDES + NoIv + 固定密碼。



encryptorBean：協力商那組 PBEWithHmacSHA512AndAES_256 + RandomIv + 動態 salt。



@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;

    }



    // 新：協力商版（安全組態）

    @Bean("encryptorBean")

    public StringEncryptor encryptorBean() {

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

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

        if (org.apache.commons.lang3.StringUtils.isBlank(p1)

                || org.apache.commons.lang3.StringUtils.isBlank(p2)

                || "null".equalsIgnoreCase(p1)

                || "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;

    }

}





使用時用 @Qualifier 指定：



@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. 組態屬性的自動解密：用「路由型」Encryptor + 多前綴



ulisesbocchio/jasypt-spring-boot 預設一次只能指定一個 jasypt.encryptor.bean 來處理組態的 ENC(...)。若你要同時支援「舊」與「新」兩種加密格式，有兩條路：



路線 1（推薦）：自訂前綴切換



定義不同前綴，例如：



新格式：ENC_NEW(...) → 用 encryptorBean



舊格式：ENC_OLD(...) → 用 legacyEncryptor



做法：提供自訂 Detector/Resolver 或一個路由型 Encryptor 配合自訂 Detector，讓它看前綴決定用哪個 encryptor。



@Configuration

public class JasyptRoutingConfig {



    @Bean("routingEncryptor")

    public StringEncryptor routingEncryptor(

            @Qualifier("legacyEncryptor") StringEncryptor legacy,

            @Qualifier("encryptorBean") StringEncryptor modern) {

        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) { /* fall through */ }

                return legacy.decrypt(encryptedMessage);

            }

        };

    }



    // 自訂前綴偵測：支援 ENC_NEW(...)、ENC_OLD(...)、也保留 ENC(...)

    @Bean

    public com.ulisesbocchio.jasyptspringboot.detector.EncryptablePropertyDetector encryptablePropertyDetector() {

        return value -> {

            if (value == null) return false;

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

        };

    }



    @Bean

    public com.ulisesbocchio.jasyptspringboot.resolver.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 指向這個「路由」能力（其實 Resolver 已經接手了，這行可以保留指向 routingEncryptor；或直接不設）：



jasypt:

  encryptor:

    bean: routingEncryptor





然後在組態檔裡你可以混用：



# 新格式（AES-256）

spring:

  datasource:

    password: "ENC_NEW(xxxxxxx...)"



# 舊格式（MD5+DES）

legacy:

  token: "ENC_OLD(yyyyyyy...)"



# 未標記舊新者（歷史遺留）

other:

  secret: "ENC(zzzzzz...)"



路線 2：只掛一個 jasypt.encryptor.bean



如果只在組態層面啟用新演算法（jasypt.encryptor.bean=encryptorBean），舊資料不再用於組態，就不需要路由。舊資料若還會在程式中用到，就改由程式碼的 @Qualifier("legacyEncryptor") 來解即可。這是最簡潔，但無法同時在組態屬性裡解兩種格式。



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



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



舊資料保留解密能力一段時間（legacyEncryptor），逐步轉檔或於讀取時即時轉存為新格式。



把組態值改標記為 ENC_NEW(...)，僅在極端相容需求時才保留 ENC_OLD(...)。



D. 典型落坑提醒



你的原始片段有些小誤植：config. setPassword(sait)（應為 salt）、config-setAlgorithm（應為 setAlgorithm）、全形括號與空白等；上面提供的程式碼已修正。



PBEWithMD5AndDES + NoIvGenerator 安全性很弱，只作相容期使用，並避免再用於新密文。



P_ENV_1/P_ENV_2 來自 JVM 系統屬性或環境變數時，要考慮空/null，已在範例處理。



JCE AES-256 在舊 JDK 曾需「無限制強度策略檔」；現代 JDK 已內建，仍建議在所有環境驗證一次。



E. 最小可用配置總結



@Bean("legacyEncryptor") + @Bean("encryptorBean") 兩組都註冊。



組態層若需同時支援兩種格式：加上自訂 Detector/Resolver（或路由 Encryptor），並允許 ENC_NEW(...)、ENC_OLD(...)。



程式碼層用 @Qualifier 精準選擇要用哪一組。



接下來若你要，我可以產生一支小測試（JUnit 或簡單 main()）幫你把明文轉成 ENC_NEW(...) / ENC_OLD(...) 兩種密文，方便你替換組態。
