FileTraceEncrypt.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it).
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.pdd.logger.filetrace;

  23. import java.security.Key;
  24. import java.util.HashMap;
  25. import java.util.Map;

  27. import org.apache.commons.lang.StringUtils;
  28. import org.apache.cxf.rs.security.jose.jwk.JsonWebKey;
  29. import org.apache.cxf.rs.security.jose.jwk.JsonWebKeys;
  30. import org.apache.cxf.rs.security.jose.jwk.JwkUtils;
  31. import org.openspcoop2.pdd.core.dynamic.DynamicMapBuilderUtils;
  32. import org.openspcoop2.protocol.sdk.Busta;
  33. import org.openspcoop2.protocol.sdk.Context;
  34. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  35. import org.openspcoop2.security.SecurityException;
  36. import org.openspcoop2.security.keystore.JWKSetStore;
  37. import org.openspcoop2.security.keystore.MerlinKeystore;
  38. import org.openspcoop2.security.keystore.PublicKeyStore;
  39. import org.openspcoop2.security.keystore.SecretKeyStore;
  40. import org.openspcoop2.security.keystore.SecretPasswordKeyDerivationConfig;
  41. import org.openspcoop2.security.keystore.cache.GestoreKeystoreCache;
  42. import org.openspcoop2.utils.UtilsException;
  43. import org.openspcoop2.utils.certificate.JWK;
  44. import org.openspcoop2.utils.certificate.JWKSet;
  45. import org.openspcoop2.utils.certificate.KeyStore;
  46. import org.openspcoop2.utils.certificate.KeyUtils;
  47. import org.openspcoop2.utils.certificate.KeystoreType;
  48. import org.openspcoop2.utils.certificate.SymmetricKeyUtils;
  49. import org.openspcoop2.utils.certificate.byok.BYOKConfig;
  50. import org.openspcoop2.utils.certificate.byok.BYOKCostanti;
  51. import org.openspcoop2.utils.certificate.byok.BYOKManager;
  52. import org.openspcoop2.utils.certificate.byok.BYOKRequestParams;
  53. import org.openspcoop2.utils.io.Base64Utilities;
  54. import org.openspcoop2.utils.io.HexBinaryUtilities;
  55. import org.openspcoop2.utils.security.Encrypt;
  56. import org.openspcoop2.utils.security.EncryptOpenSSLPass;
  57. import org.openspcoop2.utils.security.EncryptOpenSSLPassPBKDF2;
  58. import org.openspcoop2.utils.security.EncryptWrapKey;
  59. import org.openspcoop2.utils.security.JOSESerialization;
  60. import org.openspcoop2.utils.security.JWEOptions;
  61. import org.openspcoop2.utils.security.JsonEncrypt;
  62. import org.openspcoop2.utils.security.JsonUtils;
  63. import org.openspcoop2.utils.security.JwtHeaders;
  64. import org.openspcoop2.utils.security.OpenSSLEncryptionMode;
  65. import org.slf4j.Logger;

  67. import com.nimbusds.jose.jwk.KeyUse;

  69. /**     
  70.  * FileTraceEncrypt
  71.  *
  72.  * @author Poli Andrea (poli@link.it)
  73.  * @author $Author$
  74.  * @version $Rev$, $Date$
  75.  */
  76. public class FileTraceEncrypt {

  78.     private Logger log;
  79.     private RequestInfo requestInfo;
  80.     private Context context;
  81.     private Busta busta;
  82.     
  83.     public FileTraceEncrypt(Logger log, RequestInfo requestInfo, Context context, Busta busta) {
  84.         this.log = log;
  85.         this.requestInfo = requestInfo;
  86.         this.context = context;
  87.         this.busta = busta;
  88.     }
  89.     
  90.     private static final String JAVA_SEPARATOR = ".";
  91.     
  92.     private String getKeystoreError(FileTraceEncryptConfig config) {
  93.         return "Access to keystore ["+config.getKeystoreType().getNome()+"] '"+config.getKeystorePath()+"' failed";
  94.     }
  95.     private String getKeyError(FileTraceEncryptConfig config) {
  96.         return "Access to key ["+config.getKeystoreType().getNome()+"] '"+config.getKeystorePath()+"' failed";
  97.     }

  99.     private static final String KEYSTORE_PREFIX = "Keystore [";
  100.     
  101.     public String encrypt(FileTraceEncryptConfig config, 
  102.             String value) throws UtilsException {
  103.     
  104.         FileTraceEncryptKey fileTraceEncryptKey = new FileTraceEncryptKey();

  106.         boolean initPasswordKeyDerivation = false;
  107.         try {
  108.             switch (config.getKeystoreType()) {
  109.             case JKS:
  110.             case PKCS12:
  111.             case PKCS11:
  112.             case JCEKS:
  113.                 readKeystore(fileTraceEncryptKey, config);
  114.                 break;
  115.             case JWK_SET:
  116.                 readJwk(fileTraceEncryptKey, config);
  117.                 break;
  118.             case PUBLIC_KEY:
  119.                 readPublicKey(fileTraceEncryptKey, config);
  120.                 break;
  121.             case SYMMETRIC_KEY:
  122.                 readSecretKey(fileTraceEncryptKey, config);
  123.                 break;
  124.             case PASSWORD_KEY_DERIVATION:
  125.                 readPasswordKeyDerivation(fileTraceEncryptKey, config);
  126.                 initPasswordKeyDerivation = true;
  127.                 break;
  128.             default:
  129.                 throw new UtilsException(KEYSTORE_PREFIX+config.getKeystoreType().getNome()+"] unsupported");
  130.             }
  131.         }catch(Exception e) {
  132.             throw new UtilsException(e.getMessage(),e);
  133.         }
  134.         
  135.         /**System.out.println("CONF ["+config.getName()+"] java["+config.isJavaEngine()+"] jose["+config.isJoseEngine()+"]");*/
  136.         if(config.isJavaEngine()) {
  137.             if(config.isKeyWrap()) {
  138.                 if(initPasswordKeyDerivation) {
  139.                     throw new UtilsException(KEYSTORE_PREFIX+config.getKeystoreType().getNome()+"] unusable with key wrap java mode");
  140.                 }
  141.                 return encJavaKeyWrap(fileTraceEncryptKey, config, value);
  142.             }
  143.             else {
  144.                 return encJava(fileTraceEncryptKey, config, value);
  145.             }
  146.         } 
  147.         else if(config.isJoseEngine()) {
  148.             if(initPasswordKeyDerivation) {
  149.                 throw new UtilsException(KEYSTORE_PREFIX+config.getKeystoreType().getNome()+"] unusable with jose mode");
  150.             }
  151.             return encJose(fileTraceEncryptKey, config, value);
  152.         } 
  153.         else if(config.isOpenSSLEngine()) {
  154.             return encOpenSSL(fileTraceEncryptKey, config, value);
  155.         }
  156.         else {
  157.             throw new UtilsException("Encrypt mode undefined");
  158.         }
  159.         
  160.     }
  161.     
  162.     private BYOKRequestParams getBYOKRequestParams(FileTraceEncryptConfig config) throws UtilsException {
  163.         BYOKRequestParams req = null;
  164.         if(config!=null && config.getKmsId()!=null) {
  165.             BYOKManager manager = BYOKManager.getInstance();
  166.             if(manager==null) {
  167.                 throw new UtilsException("BYOKManager not initialized");
  168.             }
  169.             BYOKConfig bconfig = manager.getKMSConfigByType(config.getKmsId());
  170.             if(bconfig==null) {
  171.                 throw new UtilsException("BYOK configuration for kms id '"+config.getKmsId()+"' not found");
  172.             }
  173.             req = new BYOKRequestParams();
  174.             req.setConfig(bconfig);
  175.             
  176.             Map<String, String> inputMap = new HashMap<>();
  177.             if(config.getKmsInput()!=null && !config.getKmsInput().isEmpty()) {
  178.                 inputMap.putAll(config.getKmsInput());
  179.             }
  180.             req.setInputMap(inputMap);
  181.             
  182.             Map<String,Object> dynamicMap = DynamicMapBuilderUtils.buildDynamicMap(this.busta, this.requestInfo, this.context, this.log);
  183.             req.setDynamicMap(dynamicMap);
  184.         }
  185.         return req;
  186.     }
  187.     
  188.     private void readKeystore(FileTraceEncryptKey fileTraceEncryptKey, FileTraceEncryptConfig config) throws UtilsException, SecurityException {
  189.         String type = KeystoreType.PKCS11.equals(config.getKeystoreType()) ? config.getKeystoreHsmType() : config.getKeystoreType().getNome();
  190.         MerlinKeystore merlinKs = GestoreKeystoreCache.getMerlinKeystore(this.requestInfo,
  191.                 config.getKeystorePath(), type, 
  192.                 config.getKeystorePassword(),
  193.                 getBYOKRequestParams(config));
  194.         if(merlinKs==null || merlinKs.getKeyStore()==null) {
  195.             throw new UtilsException(getKeystoreError(config));
  196.         }
  197.         fileTraceEncryptKey.ks = merlinKs.getKeyStore();
  198.         /**if(config.isJavaEngine()) {*/
  199.         // bisogna sapere se e' secret o meno
  200.         if(KeystoreType.JCEKS.equals(config.getKeystoreType())) {
  201.             fileTraceEncryptKey.key = fileTraceEncryptKey.ks.getSecretKey(config.getKeyAlias(), config.getKeyPassword());
  202.             fileTraceEncryptKey.secret = true;
  203.         }
  204.         else {
  205.             fileTraceEncryptKey.key = merlinKs.getKeyStore().getPublicKey(config.getKeyAlias());
  206.         }
  207.         /**}*/
  208.     }
  209.     private void readJwk(FileTraceEncryptKey fileTraceEncryptKey, FileTraceEncryptConfig config) throws UtilsException, SecurityException {
  210.         JWKSetStore jwtStore = GestoreKeystoreCache.getJwkSetStore(this.requestInfo, config.getKeystorePath(),
  211.                 getBYOKRequestParams(config));
  212.         if(jwtStore==null || jwtStore.getJwkSet()==null) {
  213.             throw new UtilsException(getKeystoreError(config));
  214.         }
  215.         fileTraceEncryptKey.jsonWebKeys = jwtStore.getJwkSet().getJsonWebKeys();
  216.         /**if(config.isJavaEngine()) {*/
  217.         // bisogna sapere se e' secret o meno
  218.         JsonWebKey jwk = JsonUtils.readKey(fileTraceEncryptKey.jsonWebKeys, config.getKeyAlias());
  219.         if(jwk==null) {
  220.             throw new UtilsException("Accesso al keystore ["+config.getKeystoreType().getNome()+"] '"+config.getKeystorePath()+"' non riuscito per l'alias '"+config.getKeyAlias()+"'");
  221.         }
  222.         if(jwk.getAlgorithm()==null) {
  223.             jwk.setAlgorithm(config.isJavaEngine() ? "A256GCM" : config.getContentAlgorithm());
  224.         }
  225.         if(config.getKeyAlgorithm().contains(KeyUtils.ALGO_RSA)) {
  226.             fileTraceEncryptKey.key = JwkUtils.toRSAPublicKey(jwk);
  227.         }
  228.         else if(config.getKeyAlgorithm().contains(KeyUtils.ALGO_EC)) {
  229.             fileTraceEncryptKey.key = JwkUtils.toECPublicKey(jwk);
  230.         }
  231.         else {
  232.             fileTraceEncryptKey.key = JwkUtils.toSecretKey(jwk);
  233.             fileTraceEncryptKey.secret = true;
  234.         }
  235.         /**}*/
  236.     }
  237.     
  238.     private byte[] readKeyInline(FileTraceEncryptConfig config) throws SecurityException {
  239.         String keyInLine = config.getKeyInline();
  240.         byte [] key = null;
  241.         if(config.isKeyBase64Encoding()) {
  242.             key = Base64Utilities.decode(keyInLine.getBytes());
  243.         }
  244.         else if(config.isKeyHexEncoding()) {
  245.             try {
  246.                 key = HexBinaryUtilities.decode(keyInLine);
  247.             }catch(Exception e) {
  248.                 throw new SecurityException(e.getMessage());
  249.             }
  250.         }
  251.         else {
  252.             key = keyInLine.getBytes();
  253.         }
  254.         return key;
  255.     }
  256.     private byte[] readEncodedKeyFromPath(FileTraceEncryptConfig config) throws SecurityException {
  257.         byte [] encodedKey = GestoreKeystoreCache.getExternalResource(this.requestInfo, config.getKeyPath(), null).getResource();
  258.         byte [] key = null;
  259.         if(config.isKeyBase64Encoding()) {
  260.             key = Base64Utilities.decode(encodedKey);
  261.         }
  262.         else {
  263.             try {
  264.                 key = HexBinaryUtilities.decode(new String(encodedKey));
  265.             }catch(Exception e) {
  266.                 throw new SecurityException(e.getMessage());
  267.             }
  268.         }
  269.         return key;
  270.     }
  271.     
  272.     private String readPublicKeyAlgo(FileTraceEncryptConfig config) {
  273.         String algo = config.getKeyAlgorithm();
  274.         if(config.isJoseEngine() || config.isKeyWrap()) {
  275.             if(config.getKeyAlgorithm().contains(KeyUtils.ALGO_RSA)) {
  276.                 algo = KeyUtils.ALGO_RSA;
  277.             }
  278.             else if(config.getKeyAlgorithm().contains(KeyUtils.ALGO_DSA)) {
  279.                 algo = KeyUtils.ALGO_DSA;
  280.             }
  281.             else if(config.getKeyAlgorithm().contains(KeyUtils.ALGO_DH)) {
  282.                 algo = KeyUtils.ALGO_DH;
  283.             }
  284.             else if(config.getKeyAlgorithm().contains(KeyUtils.ALGO_EC)) {
  285.                 algo = KeyUtils.ALGO_EC;
  286.             }
  287.             else {
  288.                 algo = KeyUtils.ALGO_RSA;
  289.             }
  290.         }
  291.         return algo;
  292.     }
  293.     private void readPublicKey(FileTraceEncryptKey fileTraceEncryptKey, FileTraceEncryptConfig config) throws UtilsException, SecurityException {
  294.         String algo = readPublicKeyAlgo(config);
  295.         
  296.         PublicKeyStore publicKeyStore = null;
  297.         if(config.getKeyInline()!=null && StringUtils.isNotEmpty(config.getKeyInline())) {
  298.             byte [] key = readKeyInline(config);
  299.             publicKeyStore = GestoreKeystoreCache.getPublicKeyStore(this.requestInfo, key, algo);
  300.         }
  301.         else {
  302.             if(config.isKeyBase64Encoding() || config.isKeyHexEncoding()) {
  303.                 byte [] key = readEncodedKeyFromPath(config);
  304.                 publicKeyStore = GestoreKeystoreCache.getPublicKeyStore(this.requestInfo, key, algo);
  305.             }
  306.             else {
  307.                 publicKeyStore = GestoreKeystoreCache.getPublicKeyStore(this.requestInfo, config.getKeyPath(), algo);
  308.             }
  309.         }
  310.         if(publicKeyStore==null) {
  311.             throw new UtilsException(getKeyError(config));
  312.         }
  313.         fileTraceEncryptKey.key = publicKeyStore.getPublicKey();
  314.         if(config.isJoseEngine()) {
  315.             if(config.getKeyId()!=null && StringUtils.isNotEmpty(config.getKeyId())) {
  316.                 config.setKeyAlias(config.getKeyId());
  317.             }
  318.             else {
  319.                 config.generateKeyAlias();
  320.             }
  321.             JWK jwk = new JWK(publicKeyStore.getPublicKey(), config.getKeyAlias());
  322.             JWKSet jwkSet = new JWKSet();
  323.             jwkSet.addJwk(jwk);
  324.             jwkSet.getJson(); // rebuild
  325.             fileTraceEncryptKey.jsonWebKeys = jwkSet.getJsonWebKeys();
  326.         }
  327.     }
  328.     private void readSecretKey(FileTraceEncryptKey fileTraceEncryptKey, FileTraceEncryptConfig config) throws UtilsException, SecurityException {
  329.         String algo = config.isJoseEngine() ? SymmetricKeyUtils.ALGO_AES : config.getKeyAlgorithm();
  330.         SecretKeyStore secretKeyStore = null;
  331.         if(config.getKeyInline()!=null && StringUtils.isNotEmpty(config.getKeyInline())) {
  332.             byte [] key = readKeyInline(config);
  333.             secretKeyStore = GestoreKeystoreCache.getSecretKeyStore(this.requestInfo, key, algo,
  334.                     getBYOKRequestParams(config));
  335.         }
  336.         else {
  337.             if(config.isKeyBase64Encoding() || config.isKeyHexEncoding()) {
  338.                 byte [] key = readEncodedKeyFromPath(config);
  339.                 secretKeyStore = GestoreKeystoreCache.getSecretKeyStore(this.requestInfo, key, algo,
  340.                         getBYOKRequestParams(config));
  341.             }
  342.             else {
  343.                 secretKeyStore = GestoreKeystoreCache.getSecretKeyStore(this.requestInfo, config.getKeyPath(), algo,
  344.                         getBYOKRequestParams(config));
  345.             }
  346.         }
  347.         initSecretKey(secretKeyStore, fileTraceEncryptKey, config);
  348.     }
  349.     private void readPasswordKeyDerivation(FileTraceEncryptKey fileTraceEncryptKey, FileTraceEncryptConfig config) throws UtilsException, SecurityException {
  350.         fileTraceEncryptKey.pwdKeyDerivationConfig = new SecretPasswordKeyDerivationConfig(config.getPassword(), config.getPasswordType(), config.getPasswordIteration());
  351.         if(!config.isOpenSSLEngine() ) {
  352.             SecretKeyStore secretKeyStore = GestoreKeystoreCache.getSecretKeyStore(this.requestInfo, fileTraceEncryptKey.pwdKeyDerivationConfig,
  353.                     getBYOKRequestParams(config));
  354.             initSecretKey(secretKeyStore, fileTraceEncryptKey, config);
  355.         }
  356.     }
  357.     private void initSecretKey(SecretKeyStore secretKeyStore, FileTraceEncryptKey fileTraceEncryptKey, FileTraceEncryptConfig config) throws UtilsException, SecurityException {
  358.         if(secretKeyStore==null) {
  359.             throw new UtilsException(getKeyError(config));
  360.         }
  361.         fileTraceEncryptKey.key = secretKeyStore.getSecretKey();
  362.         fileTraceEncryptKey.iv = secretKeyStore.getIv();
  363.         fileTraceEncryptKey.salt = secretKeyStore.getSalt();
  364.         fileTraceEncryptKey.secret = true;
  365.         if(config.isJoseEngine()) {
  366.             if(config.getKeyId()!=null && StringUtils.isNotEmpty(config.getKeyId())) {
  367.                 config.setKeyAlias(config.getKeyId());
  368.             }
  369.             else {
  370.                 config.generateKeyAlias();
  371.             }
  372.             JWK jwk = new JWK(secretKeyStore.getSecretKey(), config.getKeyAlias(), KeyUse.ENCRYPTION);
  373.             JWKSet jwkSet = new JWKSet();
  374.             jwkSet.addJwk(jwk);
  375.             jwkSet.getJson(); // rebuild
  376.             fileTraceEncryptKey.jsonWebKeys = jwkSet.getJsonWebKeys();
  377.         }
  378.     }
  379.     
  380.     private String encJava(FileTraceEncryptKey fileTraceEncryptKey, FileTraceEncryptConfig config, String value) throws UtilsException {
  381.         
  382.         Encrypt encrypt = null;
  383.         if(fileTraceEncryptKey.secret &&
  384.                 fileTraceEncryptKey.iv!=null) {
  385.             encrypt = new Encrypt(fileTraceEncryptKey.key, fileTraceEncryptKey.iv);
  386.         }
  387.         else {
  388.             encrypt = new Encrypt(fileTraceEncryptKey.key);
  389.         }
  390.         
  391.         if(fileTraceEncryptKey.secret &&
  392.                 fileTraceEncryptKey.iv==null) {
  393.             encrypt.initIV(config.getContentAlgorithm());
  394.         }
  395.         
  396.         byte [] encrypted = null;
  397.         try {
  398.             /**System.out.println("encrypt ["+config.getContentAlgorithm()+"]...");*/
  399.             encrypted = encrypt.encrypt(value.getBytes(), config.getContentAlgorithm());
  400.             /**System.out.println("encrypt ok");*/
  401.         }catch(Exception e) {
  402.             /**System.out.println("encrypt ERROR: "+e.getMessage());*/
  403.             throw new UtilsException(e.getMessage(),e);
  404.         }
  405.         
  406.         if(fileTraceEncryptKey.secret &&
  407.                 fileTraceEncryptKey.salt!=null){
  408.             encrypted = EncryptOpenSSLPass.formatOutput(fileTraceEncryptKey.salt, encrypted);
  409.         }
  410.         
  411.         String en = null;
  412.         if(config.isBase64Encoding()) {
  413.             en = Base64Utilities.encodeAsString(encrypted);
  414.         }
  415.         else if(config.isHexEncoding()) {
  416.             en = HexBinaryUtilities.encodeAsString(encrypted);
  417.         }
  418.         else {
  419.             throw new UtilsException("Java algorithm undefined in keystore ["+config.getKeystoreType().getNome()+"] '"+config.getKeystorePath()+"'");
  420.         }
  421.         if(fileTraceEncryptKey.secret) {
  422.             if(config.isBase64Encoding()) {
  423.                 return encrypt.getIVBase64AsString()+JAVA_SEPARATOR+en;
  424.             }
  425.             else {
  426.                 return encrypt.getIVHexBinaryAsString()+JAVA_SEPARATOR+en;
  427.             }
  428.         }
  429.         return en;
  430.     }
  431.     
  432.     private String encJavaKeyWrap(FileTraceEncryptKey fileTraceEncryptKey, FileTraceEncryptConfig config, String value) throws UtilsException {
  433.         
  434.         EncryptWrapKey encrypt = null;
  435.         if(fileTraceEncryptKey.ks!=null) {
  436.             encrypt = new EncryptWrapKey(fileTraceEncryptKey.ks, config.getKeyAlias());
  437.         }
  438.         else {
  439.             encrypt = new EncryptWrapKey(fileTraceEncryptKey.key);
  440.         }
  441.                 
  442.         byte [] encrypted = null;
  443.         try {
  444.             /**System.out.println("encrypt ["+config.getKeyAlgorithm()+"] ["+config.getContentAlgorithm()+"]...");*/
  445.             encrypted = encrypt.encrypt(value.getBytes(), config.getKeyAlgorithm(), config.getContentAlgorithm());
  446.             /**System.out.println("encrypt ok");*/
  447.         }catch(Exception e) {
  448.             /**System.out.println("encrypt ERROR: "+e.getMessage());*/
  449.             throw new UtilsException(e.getMessage(),e);
  450.         }
  451.         
  452.         String en = null;
  453.         if(config.isBase64Encoding()) {
  454.             en = Base64Utilities.encodeAsString(encrypted);
  455.         }
  456.         else if(config.isHexEncoding()) {
  457.             en = HexBinaryUtilities.encodeAsString(encrypted);
  458.         }
  459.         else {
  460.             throw new UtilsException("Java algorithm undefined in keystore ["+config.getKeystoreType().getNome()+"] '"+config.getKeystorePath()+"'");
  461.         }

  463.         if(config.isBase64Encoding()) {
  464.             return encrypt.getWrappedKeyBase64()+JAVA_SEPARATOR+encrypt.getIVBase64AsString()+JAVA_SEPARATOR+en;
  465.         }
  466.         else {
  467.             return encrypt.getWrappedKeyHexBinary()+JAVA_SEPARATOR+encrypt.getIVHexBinaryAsString()+JAVA_SEPARATOR+en;
  468.         }
  469.         
  470.     }
  471.     
  472.     private String encJose(FileTraceEncryptKey fileTraceEncryptKey, FileTraceEncryptConfig config, String value) throws UtilsException {
  473.         JsonEncrypt encrypt = null;
  474.         JwtHeaders jwtHeaders = null;
  475.         JWEOptions options = new JWEOptions(JOSESerialization.COMPACT);
  476.         if(fileTraceEncryptKey.ks!=null) {
  477.             jwtHeaders = config.getJwtHeaders(fileTraceEncryptKey.ks);
  478.             if(fileTraceEncryptKey.secret) {
  479.                 encrypt = new JsonEncrypt(fileTraceEncryptKey.ks, config.getKeyAlias(), config.getKeyPassword(), config.getKeyAlgorithm(), config.getContentAlgorithm(),
  480.                         jwtHeaders, options); 
  481.             }
  482.             else {
  483.                 encrypt = new JsonEncrypt(fileTraceEncryptKey.ks, config.getKeyAlias(), config.getKeyAlgorithm(), config.getContentAlgorithm(),
  484.                         jwtHeaders, options); 
  485.             }
  486.         }
  487.         else {
  488.             jwtHeaders = config.getJwtHeaders(fileTraceEncryptKey.jsonWebKeys);
  489.             encrypt = new JsonEncrypt(fileTraceEncryptKey.jsonWebKeys, fileTraceEncryptKey.secret, config.getKeyAlias(), config.getKeyAlgorithm(), config.getContentAlgorithm(),
  490.                     jwtHeaders, options); 
  491.         }
  492.         return encrypt.encrypt(value);
  493.     }
  494.     
  495.     private String encOpenSSL(FileTraceEncryptKey fileTraceEncryptKey, FileTraceEncryptConfig config, String value) throws UtilsException {
  496.         if(BYOKCostanti.isOpenSSLPBKDF2PasswordDerivationKeyMode(fileTraceEncryptKey.pwdKeyDerivationConfig.getPasswordEncryptionMode())) {
  497.             return encOpenSSLPBKDF2(fileTraceEncryptKey, config, value);
  498.         }
  499.         else {
  500.             return encOpenSSLStandard(fileTraceEncryptKey, config, value);
  501.         }
  502.     }
  503.     private String encOpenSSLStandard(FileTraceEncryptKey fileTraceEncryptKey, FileTraceEncryptConfig config, String value) throws UtilsException {
  504.         
  505.         SecretPasswordKeyDerivationConfig passwordKeyDerivationConfig = fileTraceEncryptKey.pwdKeyDerivationConfig;
  506.         
  507.         EncryptOpenSSLPass encrypt = new EncryptOpenSSLPass(passwordKeyDerivationConfig.getPassword(), 
  508.                 OpenSSLEncryptionMode.toMode(passwordKeyDerivationConfig.getPasswordEncryptionMode()));
  509.         
  510.         if(config.isBase64Encoding()) {
  511.             return encrypt.encryptBase64AsString(value.getBytes());
  512.         }
  513.         else if(config.isHexEncoding()) {
  514.             return encrypt.encryptHexBinaryAsString(value.getBytes());
  515.         }
  516.         else {
  517.             throw new UtilsException("Encoding mode undefined");
  518.         }
  519.     }
  520.     private String encOpenSSLPBKDF2(FileTraceEncryptKey fileTraceEncryptKey, FileTraceEncryptConfig config, String value) throws UtilsException {
  521.         
  522.         SecretPasswordKeyDerivationConfig passwordKeyDerivationConfig = fileTraceEncryptKey.pwdKeyDerivationConfig;
  523.         
  524.         EncryptOpenSSLPassPBKDF2 encrypt = new EncryptOpenSSLPassPBKDF2(passwordKeyDerivationConfig.getPassword(), 
  525.                 passwordKeyDerivationConfig.getPasswordIterator(), 
  526.                 OpenSSLEncryptionMode.toMode(passwordKeyDerivationConfig.getPasswordEncryptionMode()));
  527.         
  528.         if(config.isBase64Encoding()) {
  529.             return encrypt.encryptBase64AsString(value.getBytes());
  530.         }
  531.         else if(config.isHexEncoding()) {
  532.             return encrypt.encryptHexBinaryAsString(value.getBytes());
  533.         }
  534.         else {
  535.             throw new UtilsException("Encoding mode undefined");
  536.         }
  537.     }
  538. }

  540. class FileTraceEncryptKey{
  541.     Key key = null;
  542.     byte[]iv = null;
  543.     byte[]salt = null;
  544.     boolean secret = false;
  545.     KeyStore ks = null;
  546.     JsonWebKeys jsonWebKeys = null;
  547.     SecretPasswordKeyDerivationConfig pwdKeyDerivationConfig = null;
  548. }
Created with JaCoCo 0.8.8.202204050719