BYOKLocalEncrypt.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.security.keystore;

  23. import java.security.Key;
  24. import java.security.cert.Certificate;
  25. import java.security.cert.X509Certificate;

  27. import javax.crypto.SecretKey;

  29. import org.apache.commons.lang.StringUtils;
  30. import org.apache.cxf.rs.security.jose.jwk.JsonWebKey;
  31. import org.apache.cxf.rs.security.jose.jwk.JsonWebKeys;
  32. import org.apache.cxf.rs.security.jose.jwk.JwkUtils;
  33. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  34. import org.openspcoop2.security.SecurityException;
  35. import org.openspcoop2.security.keystore.cache.GestoreKeystoreCache;
  36. import org.openspcoop2.utils.UtilsException;
  37. import org.openspcoop2.utils.certificate.JWK;
  38. import org.openspcoop2.utils.certificate.JWKSet;
  39. import org.openspcoop2.utils.certificate.KeyStore;
  40. import org.openspcoop2.utils.certificate.KeyUtils;
  41. import org.openspcoop2.utils.certificate.KeystoreType;
  42. import org.openspcoop2.utils.certificate.SymmetricKeyUtils;
  43. import org.openspcoop2.utils.certificate.byok.BYOKCostanti;
  44. import org.openspcoop2.utils.certificate.byok.BYOKLocalConfig;
  45. import org.openspcoop2.utils.io.Base64Utilities;
  46. import org.openspcoop2.utils.io.HexBinaryUtilities;
  47. import org.openspcoop2.utils.security.CipherInfo;
  48. import org.openspcoop2.utils.security.Decrypt;
  49. import org.openspcoop2.utils.security.DecryptOpenSSLPass;
  50. import org.openspcoop2.utils.security.DecryptOpenSSLPassPBKDF2;
  51. import org.openspcoop2.utils.security.DecryptWrapKey;
  52. import org.openspcoop2.utils.security.Encrypt;
  53. import org.openspcoop2.utils.security.EncryptOpenSSLPass;
  54. import org.openspcoop2.utils.security.EncryptOpenSSLPassPBKDF2;
  55. import org.openspcoop2.utils.security.EncryptWrapKey;
  56. import org.openspcoop2.utils.security.JOSESerialization;
  57. import org.openspcoop2.utils.security.JWEOptions;
  58. import org.openspcoop2.utils.security.JWTOptions;
  59. import org.openspcoop2.utils.security.JsonDecrypt;
  60. import org.openspcoop2.utils.security.JsonEncrypt;
  61. import org.openspcoop2.utils.security.JsonUtils;
  62. import org.openspcoop2.utils.security.JwtHeaders;
  63. import org.openspcoop2.utils.security.OpenSSLEncryptionMode;

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

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

  76.     private RequestInfo requestInfo;
  77.     
  78.     public BYOKLocalEncrypt(RequestInfo requestInfo) {
  79.         this.requestInfo = requestInfo;
  80.     }
  81.     public BYOKLocalEncrypt() {
  82.     }
  83.     
  84.     private static final String JAVA_SEPARATOR = ".";
  85.     
  86.     private String getKeystoreError(BYOKLocalConfig config) {
  87.         return "Access to keystore ["+config.getKeystoreType().getNome()+"] '"+config.getKeystorePath()+"' failed";
  88.     }
  89.     private String getKeyError(BYOKLocalConfig config) {
  90.         return "Access to key ["+config.getKeystoreType().getNome()+"] '"+config.getKeystorePath()+"' failed";
  91.     }
  92.     private static final String ENCODING_MODE_UNDEFINED = "Encoding mode undefined";
  93.     private static final String KEYSTORE_PREFIX = "Keystore [";
  94.     
  95.     public String wrap(BYOKLocalConfig config, 
  96.             String value) throws UtilsException {
  97.         return wrap(config, 
  98.                 value.getBytes());
  99.     }
  100.     public String wrap(BYOKLocalConfig config, 
  101.             byte[] value) throws UtilsException {
  102.         
  103.         BYOKEncryptKey byokEncryptKey = new BYOKEncryptKey();

  105.         boolean initPasswordKeyDerivation = false;
  106.         try {
  107.             switch (config.getKeystoreType()) {
  108.             case JKS:
  109.             case PKCS12:
  110.             case PKCS11:
  111.             case JCEKS:
  112.                 readKeystore(byokEncryptKey, config, true);
  113.                 break;
  114.             case JWK_SET:
  115.                 readJwk(byokEncryptKey, config, true);
  116.                 break;
  117.             case PUBLIC_KEY:
  118.                 readPublicKey(byokEncryptKey, config);
  119.                 break;
  120.             case SYMMETRIC_KEY:
  121.                 readSecretKey(byokEncryptKey, config);
  122.                 break;
  123.             case PASSWORD_KEY_DERIVATION:
  124.                 readPasswordKeyDerivation(byokEncryptKey, config, true);
  125.                 initPasswordKeyDerivation = true;
  126.                 break;
  127.             default:
  128.                 throw new UtilsException(KEYSTORE_PREFIX+config.getKeystoreType().getNome()+"] unsupported");
  129.             }
  130.         }catch(Exception e) {
  131.             throw new UtilsException(e.getMessage(),e);
  132.         }
  133.         
  134.         /**System.out.println("CONF ["+config.getName()+"] java["+config.isJavaEngine()+"] jose["+config.isJoseEngine()+"]");*/
  135.         if(config.isJavaEngine()) {
  136.             if(config.isKeyWrap()) {
  137.                 if(initPasswordKeyDerivation) {
  138.                     throw new UtilsException(KEYSTORE_PREFIX+config.getKeystoreType().getNome()+"] unusable with key wrap java mode");
  139.                 }
  140.                 return encJavaKeyWrap(byokEncryptKey, config, value);
  141.             }
  142.             else {
  143.                 return encJava(byokEncryptKey, config, value);
  144.             }
  145.         } 
  146.         else if(config.isJoseEngine()) {
  147.             if(initPasswordKeyDerivation) {
  148.                 throw new UtilsException(KEYSTORE_PREFIX+config.getKeystoreType().getNome()+"] unusable with jose mode");
  149.             }
  150.             return encJose(byokEncryptKey, config, value);
  151.         } 
  152.         else if(config.isOpenSSLEngine()) {
  153.             return encOpenSSL(byokEncryptKey, config, value);
  154.         }
  155.         else {
  156.             throw new UtilsException("Encrypt mode undefined");
  157.         }
  158.         
  159.     }
  160.     
  161.     public byte[] unwrap(BYOKLocalConfig config, 
  162.             byte[] value) throws UtilsException {
  163.         return unwrap(config, new String(value));
  164.     }
  165.     public byte[] unwrap(BYOKLocalConfig config, 
  166.             String value) throws UtilsException {
  167.         
  168.         BYOKEncryptKey byokEncryptKey = new BYOKEncryptKey();

  170.         boolean initPasswordKeyDerivation = false;
  171.         try {
  172.             switch (config.getKeystoreType()) {
  173.             case JKS:
  174.             case PKCS12:
  175.             case PKCS11:
  176.             case JCEKS:
  177.                 readKeystore(byokEncryptKey, config, false);
  178.                 break;
  179.             case JWK_SET:
  180.                 readJwk(byokEncryptKey, config, false);
  181.                 break;
  182.             case KEY_PAIR:
  183.                 readKeyPair(byokEncryptKey, config);
  184.                 break;
  185.             case SYMMETRIC_KEY:
  186.                 readSecretKey(byokEncryptKey, config);
  187.                 break;
  188.             case PASSWORD_KEY_DERIVATION:
  189.                 readPasswordKeyDerivation(byokEncryptKey, config, false);
  190.                 initPasswordKeyDerivation = true;
  191.                 break;
  192.             default:
  193.                 throw new UtilsException(KEYSTORE_PREFIX+config.getKeystoreType().getNome()+"] unsupported");
  194.             }
  195.         }catch(Exception e) {
  196.             throw new UtilsException(e.getMessage(),e);
  197.         }
  198.         
  199.         /**System.out.println("CONF ["+config.getName()+"] java["+config.isJavaEngine()+"] jose["+config.isJoseEngine()+"]");*/
  200.         if(config.isJavaEngine()) {
  201.             return unwrapJava(initPasswordKeyDerivation, config, value, byokEncryptKey);
  202.         } 
  203.         else if(config.isJoseEngine()) {
  204.             if(initPasswordKeyDerivation) {
  205.                 throw new UtilsException(KEYSTORE_PREFIX+config.getKeystoreType().getNome()+"] unusable with jose mode");
  206.             }
  207.             return decryptJose(byokEncryptKey, config, value);
  208.         }
  209.         else if(config.isOpenSSLEngine()) {
  210.             return decryptOpenSSL(byokEncryptKey, config, value);
  211.         }
  212.         else {
  213.             throw new UtilsException("Encrypt mode undefined");
  214.         }
  215.         
  216.     }
  217.     private byte[] unwrapJava(boolean initPasswordKeyDerivation, BYOKLocalConfig config, String value, BYOKEncryptKey byokEncryptKey) throws UtilsException {
  218.         if(initPasswordKeyDerivation) {
  219.             if(config.isKeyWrap()) {
  220.                 throw new UtilsException(KEYSTORE_PREFIX+config.getKeystoreType().getNome()+"] unusable with key wrap java mode");
  221.             }
  222.             else {
  223.                 readJavaPasswordKeyDerivationForUnwrap(byokEncryptKey, config, value);
  224.             }
  225.         }
  226.         if(config.isKeyWrap()) {
  227.             return decryptJavaKeyWrap(byokEncryptKey, config, value);
  228.         }
  229.         else {
  230.             return decryptJava(byokEncryptKey, config, value);
  231.         }
  232.     }
  233.     
  234.     
  235.     private void readKeystore(BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config, boolean wrap) throws UtilsException, SecurityException {
  236.         String type = KeystoreType.PKCS11.equals(config.getKeystoreType()) ? config.getKeystoreHsmType() : config.getKeystoreType().getNome();
  237.         MerlinKeystore merlinKs = GestoreKeystoreCache.getMerlinKeystore(this.requestInfo,
  238.                 config.getKeystorePath(), type, 
  239.                 config.getKeystorePassword());
  240.         if(merlinKs==null || merlinKs.getKeyStore()==null) {
  241.             throw new UtilsException(getKeystoreError(config));
  242.         }
  243.         byokEncryptKey.ks = merlinKs.getKeyStore();
  244.         // bisogna sapere se e' secret o meno
  245.         if(KeystoreType.JCEKS.equals(config.getKeystoreType())) {
  246.             byokEncryptKey.key = byokEncryptKey.ks.getSecretKey(config.getKeyAlias(), config.getKeyPassword());
  247.             byokEncryptKey.secret = true;
  248.         }
  249.         else if(wrap) {
  250.             byokEncryptKey.key = merlinKs.getKeyStore().getPublicKey(config.getKeyAlias());
  251.         }
  252.         else {
  253.             byokEncryptKey.key = merlinKs.getKeyStore().getPrivateKey(config.getKeyAlias(), config.getKeyPassword());
  254.         }
  255.     }
  256.     private void readJwk(BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config, boolean wrap) throws UtilsException, SecurityException {
  257.         JWKSetStore jwtStore = GestoreKeystoreCache.getJwkSetStore(this.requestInfo, config.getKeystorePath());
  258.         if(jwtStore==null || jwtStore.getJwkSet()==null) {
  259.             throw new UtilsException(getKeystoreError(config));
  260.         }
  261.         byokEncryptKey.jsonWebKeys = jwtStore.getJwkSet().getJsonWebKeys();
  262.         /**if(config.isJavaEngine()) {*/
  263.         // bisogna sapere se e' secret o meno
  264.         JsonWebKey jwk = JsonUtils.readKey(byokEncryptKey.jsonWebKeys, config.getKeyAlias());
  265.         if(jwk==null) {
  266.             throw new UtilsException("Access to keystore ["+config.getKeystoreType().getNome()+"] '"+config.getKeystorePath()+"' failed for alias '"+config.getKeyAlias()+"'");
  267.         }
  268.         if(jwk.getAlgorithm()==null) {
  269.             jwk.setAlgorithm(config.isJavaEngine() ? "A256GCM" : config.getContentAlgorithm());
  270.         }
  271.         if(config.getKeyAlgorithm().contains(KeyUtils.ALGO_RSA)) {
  272.             if(wrap) {
  273.                 byokEncryptKey.key = JwkUtils.toRSAPublicKey(jwk);
  274.             }
  275.             else {
  276.                 byokEncryptKey.key = JwkUtils.toRSAPrivateKey(jwk);
  277.             }
  278.         }
  279.         else if(config.getKeyAlgorithm().contains(KeyUtils.ALGO_EC)) {
  280.             if(wrap) {
  281.                 byokEncryptKey.key = JwkUtils.toECPublicKey(jwk);
  282.             }
  283.             else {
  284.                 byokEncryptKey.key = JwkUtils.toECPrivateKey(jwk);
  285.             }
  286.         }
  287.         else {
  288.             byokEncryptKey.key = JwkUtils.toSecretKey(jwk);
  289.             byokEncryptKey.secret = true;
  290.         }
  291.         /**}*/
  292.     }
  293.     
  294.     private String readKeyAlgo(BYOKLocalConfig config) {
  295.         String algo = config.getKeyAlgorithm();
  296.         if(config.isJoseEngine() || config.isKeyWrap()) {
  297.             if(config.getKeyAlgorithm().contains(KeyUtils.ALGO_RSA)) {
  298.                 algo = KeyUtils.ALGO_RSA;
  299.             }
  300.             else if(config.getKeyAlgorithm().contains(KeyUtils.ALGO_DSA)) {
  301.                 algo = KeyUtils.ALGO_DSA;
  302.             }
  303.             else if(config.getKeyAlgorithm().contains(KeyUtils.ALGO_DH)) {
  304.                 algo = KeyUtils.ALGO_DH;
  305.             }
  306.             else if(config.getKeyAlgorithm().contains(KeyUtils.ALGO_EC)) {
  307.                 algo = KeyUtils.ALGO_EC;
  308.             }
  309.             else {
  310.                 algo = KeyUtils.ALGO_RSA;
  311.             }
  312.         }
  313.         return algo;
  314.     }
  315.     
  316.     private byte[] readKeyInline(BYOKLocalConfig config) throws SecurityException {
  317.         String keyInLine = config.getKeyInline();
  318.         byte [] key = null;
  319.         if(config.isKeyBase64Encoding()) {
  320.             key = Base64Utilities.decode(keyInLine.getBytes());
  321.         }
  322.         else if(config.isKeyHexEncoding()) {
  323.             try {
  324.                 key = HexBinaryUtilities.decode(keyInLine);
  325.             }catch(Exception e) {
  326.                 throw new SecurityException(e.getMessage());
  327.             }
  328.         }
  329.         else {
  330.             key = keyInLine.getBytes();
  331.         }
  332.         return key;
  333.     }
  334.     private byte[] readEncodedKeyFromPath(BYOKLocalConfig config) throws SecurityException {
  335.         byte [] encodedKey = GestoreKeystoreCache.getExternalResource(this.requestInfo, config.getKeyPath(), null).getResource();
  336.         byte [] key = null;
  337.         if(config.isKeyBase64Encoding()) {
  338.             key = Base64Utilities.decode(encodedKey);
  339.         }
  340.         else {
  341.             try {
  342.                 key = HexBinaryUtilities.decode(new String(encodedKey));
  343.             }catch(Exception e) {
  344.                 throw new SecurityException(e.getMessage());
  345.             }
  346.         }
  347.         return key;
  348.     }
  349.     
  350.     private byte[] readPublicKeyInline(BYOKLocalConfig config) throws SecurityException {
  351.         String publicKeyInLine = config.getPublicKeyInline();
  352.         byte [] key = null;
  353.         if(config.isPublicKeyBase64Encoding()) {
  354.             key = Base64Utilities.decode(publicKeyInLine.getBytes());
  355.         }
  356.         else if(config.isPublicKeyHexEncoding()) {
  357.             try {
  358.                 key = HexBinaryUtilities.decode(publicKeyInLine);
  359.             }catch(Exception e) {
  360.                 throw new SecurityException(e.getMessage());
  361.             }
  362.         }
  363.         else {
  364.             key = publicKeyInLine.getBytes();
  365.         }
  366.         return key;
  367.     }
  368.     private byte[] readEncodedPublicKeyFromPath(BYOKLocalConfig config) throws SecurityException {
  369.         byte [] encodedKey = GestoreKeystoreCache.getExternalResource(this.requestInfo, config.getPublicKeyPath(), null).getResource();
  370.         byte [] key = null;
  371.         if(config.isPublicKeyBase64Encoding()) {
  372.             key = Base64Utilities.decode(encodedKey);
  373.         }
  374.         else {
  375.             try {
  376.                 key = HexBinaryUtilities.decode(new String(encodedKey));
  377.             }catch(Exception e) {
  378.                 throw new SecurityException(e.getMessage());
  379.             }
  380.         }
  381.         return key;
  382.     }
  383.     
  384.     private void readPublicKey(BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config) throws UtilsException, SecurityException {
  385.         
  386.         String algo = readKeyAlgo(config);
  387.         
  388.         PublicKeyStore publicKeyStore = null;
  389.         if(config.getKeyInline()!=null && StringUtils.isNotEmpty(config.getKeyInline())) {
  390.             byte [] key = readKeyInline(config);
  391.             publicKeyStore = GestoreKeystoreCache.getPublicKeyStore(this.requestInfo, key, algo);
  392.         }
  393.         else {
  394.             if(config.isKeyBase64Encoding() || config.isKeyHexEncoding()) {
  395.                 byte [] key = readEncodedKeyFromPath(config);
  396.                 publicKeyStore = GestoreKeystoreCache.getPublicKeyStore(this.requestInfo, key, algo);
  397.             }
  398.             else {
  399.                 publicKeyStore = GestoreKeystoreCache.getPublicKeyStore(this.requestInfo, config.getKeyPath(), algo);
  400.             }
  401.         }
  402.         if(publicKeyStore==null) {
  403.             throw new UtilsException(getKeyError(config));
  404.         }
  405.         byokEncryptKey.key = publicKeyStore.getPublicKey();
  406.         if(config.isJoseEngine()) {
  407.             if(config.getKeyId()!=null && StringUtils.isNotEmpty(config.getKeyId())) {
  408.                 config.setKeyAlias(config.getKeyId());
  409.             }
  410.             else {
  411.                 config.generateKeyAlias();
  412.             }
  413.             JWK jwk = new JWK(publicKeyStore.getPublicKey(), config.getKeyAlias());
  414.             JWKSet jwkSet = new JWKSet();
  415.             jwkSet.addJwk(jwk);
  416.             jwkSet.getJson(); // rebuild
  417.             byokEncryptKey.jsonWebKeys = jwkSet.getJsonWebKeys();
  418.         }
  419.     }
  420.     private void readKeyPair(BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config) throws UtilsException, SecurityException {
  421.         
  422.         String algo = readKeyAlgo(config);
  423.         
  424.         KeyPairStore keyPairStore = getKeyPairStore(algo, config);
  425.         if(keyPairStore==null) {
  426.             throw new UtilsException(getKeyError(config));
  427.         }
  428.         byokEncryptKey.key = keyPairStore.getPrivateKey();
  429.         if(config.isJoseEngine()) {
  430.             if(config.getKeyId()!=null && StringUtils.isNotEmpty(config.getKeyId())) {
  431.                 config.setKeyAlias(config.getKeyId());
  432.             }
  433.             else {
  434.                 config.generateKeyAlias();
  435.             }
  436.             JWK jwk = new JWK(keyPairStore.getPublicKey(), keyPairStore.getPrivateKey(), config.getKeyAlias(), KeyUse.ENCRYPTION);
  437.             JWKSet jwkSet = new JWKSet();
  438.             jwkSet.addJwk(jwk);
  439.             jwkSet.getJson(); // rebuild
  440.             byokEncryptKey.jsonWebKeys = jwkSet.getJsonWebKeys();
  441.         }
  442.     }
  443.     private KeyPairStore getKeyPairStore(String algo, BYOKLocalConfig config) throws SecurityException {
  444.         KeyPairStore keyPairStore = null;
  445.         if(config.getKeyInline()!=null && StringUtils.isNotEmpty(config.getKeyInline())) {
  446.             
  447.             byte [] key = readKeyInline(config);
  448.             
  449.             if(config.getPublicKeyInline()!=null && StringUtils.isNotEmpty(config.getPublicKeyInline())) {
  450.                 byte [] publicKey = readPublicKeyInline(config);
  451.                 keyPairStore = GestoreKeystoreCache.getKeyPairStore(this.requestInfo, key, publicKey, config.getKeyPassword(), algo);
  452.             }
  453.             else {
  454.                 if(config.isPublicKeyBase64Encoding() || config.isPublicKeyHexEncoding()) {
  455.                     byte [] publicKey = readEncodedPublicKeyFromPath(config);
  456.                     keyPairStore = GestoreKeystoreCache.getKeyPairStore(this.requestInfo, key, publicKey, config.getKeyPassword(), algo);
  457.                 }
  458.                 else {
  459.                     keyPairStore = GestoreKeystoreCache.getKeyPairStore(this.requestInfo, key, config.getPublicKeyPath(), config.getKeyPassword(), algo);
  460.                 }
  461.             }
  462.         }
  463.         else {
  464.             keyPairStore = getKeyPairStoreFromPath(algo, config);
  465.         }
  466.         return keyPairStore;
  467.     }
  468.     private KeyPairStore getKeyPairStoreFromPath(String algo, BYOKLocalConfig config) throws SecurityException {
  469.         KeyPairStore keyPairStore = null;
  470.         if(config.isKeyBase64Encoding() || config.isKeyHexEncoding()) {
  471.             keyPairStore = getEncodedKeyPairStoreFromPath(algo, config);
  472.         }
  473.         else {
  474.         
  475.             if(config.getPublicKeyInline()!=null && StringUtils.isNotEmpty(config.getPublicKeyInline())) {
  476.                 byte [] publicKey = readPublicKeyInline(config);
  477.                 keyPairStore = GestoreKeystoreCache.getKeyPairStore(this.requestInfo, config.getKeyPath(), publicKey, config.getKeyPassword(), algo);
  478.             }
  479.             else {
  480.                 if(config.isPublicKeyBase64Encoding() || config.isPublicKeyHexEncoding()) {
  481.                     byte [] publicKey = readEncodedPublicKeyFromPath(config);
  482.                     keyPairStore = GestoreKeystoreCache.getKeyPairStore(this.requestInfo, config.getKeyPath(), publicKey, config.getKeyPassword(), algo);
  483.                 }
  484.                 else {
  485.                     keyPairStore = GestoreKeystoreCache.getKeyPairStore(this.requestInfo, config.getKeyPath(), config.getPublicKeyPath(), config.getKeyPassword(), algo);
  486.                 }
  487.             }
  488.             
  489.         }
  490.         return keyPairStore;
  491.     }
  492.     private KeyPairStore getEncodedKeyPairStoreFromPath(String algo, BYOKLocalConfig config) throws SecurityException {
  493.         byte [] key = readEncodedKeyFromPath(config);
  494.         
  495.         if(config.getPublicKeyInline()!=null && StringUtils.isNotEmpty(config.getPublicKeyInline())) {
  496.             byte [] publicKey = readPublicKeyInline(config);
  497.             return GestoreKeystoreCache.getKeyPairStore(this.requestInfo, key, publicKey, config.getKeyPassword(), algo);
  498.         }
  499.         else {
  500.             if(config.isPublicKeyBase64Encoding() || config.isPublicKeyHexEncoding()) {
  501.                 byte [] publicKey = readEncodedPublicKeyFromPath(config);
  502.                 return GestoreKeystoreCache.getKeyPairStore(this.requestInfo, key, publicKey, config.getKeyPassword(), algo);
  503.             }
  504.             else {
  505.                 return GestoreKeystoreCache.getKeyPairStore(this.requestInfo, key, config.getPublicKeyPath(), config.getKeyPassword(), algo);
  506.             }
  507.         }
  508.     }
  509.     private void readSecretKey(BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config) throws UtilsException, SecurityException {
  510.         String algo = config.isJoseEngine() ? SymmetricKeyUtils.ALGO_AES : config.getKeyAlgorithm();
  511.         SecretKeyStore secretKeyStore = null;
  512.         if(config.getKeyInline()!=null && StringUtils.isNotEmpty(config.getKeyInline())) {
  513.             byte [] key = readKeyInline(config);
  514.             secretKeyStore = GestoreKeystoreCache.getSecretKeyStore(this.requestInfo, key, algo);
  515.         }
  516.         else {
  517.             if(config.isKeyBase64Encoding() || config.isKeyHexEncoding()) {
  518.                 byte [] key = readEncodedKeyFromPath(config);
  519.                 secretKeyStore = GestoreKeystoreCache.getSecretKeyStore(this.requestInfo, key, algo);
  520.             }
  521.             else {
  522.                 secretKeyStore = GestoreKeystoreCache.getSecretKeyStore(this.requestInfo, config.getKeyPath(), algo);
  523.             }
  524.         }
  525.         initSecretKey(secretKeyStore, byokEncryptKey, config);
  526.     }
  527.     private void readPasswordKeyDerivation(BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config, boolean wrap) throws UtilsException, SecurityException {
  528.         byokEncryptKey.pwdKeyDerivationConfig = new SecretPasswordKeyDerivationConfig(config.getPassword(), config.getPasswordType(), config.getPasswordIteration());
  529.         if(!config.isOpenSSLEngine() && wrap ) {
  530.             SecretKeyStore secretKeyStore = GestoreKeystoreCache.getSecretKeyStore(this.requestInfo, byokEncryptKey.pwdKeyDerivationConfig);
  531.             initSecretKey(secretKeyStore, byokEncryptKey, config);
  532.         }
  533.     }
  534.     private void readJavaPasswordKeyDerivationForUnwrap(BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config, String wrapValue) throws UtilsException {
  535.         
  536.         String [] tmp = wrapValue.split("\\.");
  537.         if(tmp==null || tmp.length!=2) {
  538.             throw new UtilsException("Wrong format");
  539.         }
  540.         byte[]iv = null;
  541.         byte[]dataEncrypted = null;
  542.         if(config.isBase64Encoding()) {
  543.             iv = Base64Utilities.decode(tmp[0]);
  544.             dataEncrypted = Base64Utilities.decode(tmp[1]);
  545.         }
  546.         else if(config.isHexEncoding()) {
  547.             iv = HexBinaryUtilities.decode(tmp[0]);
  548.             dataEncrypted = HexBinaryUtilities.decode(tmp[1]);
  549.         }
  550.         else {
  551.             throw new UtilsException(ENCODING_MODE_UNDEFINED);
  552.         }
  553.         
  554.         CipherInfo cipherInfo = null;
  555.         if(BYOKCostanti.isOpenSSLPBKDF2PasswordDerivationKeyMode(byokEncryptKey.pwdKeyDerivationConfig.getPasswordEncryptionMode())) {
  556.             cipherInfo = DecryptOpenSSLPassPBKDF2.buildCipherInfo(dataEncrypted, 
  557.                     byokEncryptKey.pwdKeyDerivationConfig.getPassword(), 
  558.                     byokEncryptKey.pwdKeyDerivationConfig.getPasswordIterator(), 
  559.                     OpenSSLEncryptionMode.toMode(byokEncryptKey.pwdKeyDerivationConfig.getPasswordEncryptionMode()));
  560.         }
  561.         else {
  562.             cipherInfo = DecryptOpenSSLPass.buildCipherInfo(dataEncrypted, 
  563.                     byokEncryptKey.pwdKeyDerivationConfig.getPassword(), 
  564.                     null, 
  565.                     OpenSSLEncryptionMode.toMode(byokEncryptKey.pwdKeyDerivationConfig.getPasswordEncryptionMode()));
  566.         }
  567.         try {
  568.             initSecretKey((SecretKey) cipherInfo.getKey(), iv, cipherInfo.getSalt(),
  569.                     byokEncryptKey, config);
  570.         }catch(Exception e) {
  571.             throw new UtilsException(e.getMessage(),e);
  572.         }
  573.     }
  574.     private void initSecretKey(SecretKeyStore secretKeyStore, BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config) throws UtilsException, SecurityException {
  575.         if(secretKeyStore==null) {
  576.             throw new UtilsException(getKeyError(config));
  577.         }
  578.         initSecretKey(secretKeyStore.getSecretKey(), secretKeyStore.getIv(), secretKeyStore.getSalt(),
  579.                 byokEncryptKey, config);
  580.     }
  581.     private void initSecretKey(SecretKey key, byte[]iv, byte[]salt, 
  582.             BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config) throws UtilsException {
  583.         byokEncryptKey.key = key;
  584.         byokEncryptKey.iv = iv;
  585.         byokEncryptKey.salt = salt;
  586.         byokEncryptKey.secret = true;
  587.         if(config.isJoseEngine()) {
  588.             if(config.getKeyId()!=null && StringUtils.isNotEmpty(config.getKeyId())) {
  589.                 config.setKeyAlias(config.getKeyId());
  590.             }
  591.             else {
  592.                 config.generateKeyAlias();
  593.             }
  594.             JWK jwk = new JWK(key, config.getKeyAlias(), KeyUse.ENCRYPTION);
  595.             JWKSet jwkSet = new JWKSet();
  596.             jwkSet.addJwk(jwk);
  597.             jwkSet.getJson(); // rebuild
  598.             byokEncryptKey.jsonWebKeys = jwkSet.getJsonWebKeys();
  599.         }
  600.     }
  601.     
  602.     private String encJava(BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config, byte[] value) throws UtilsException {
  603.         
  604.         Encrypt encrypt = null;
  605.         if(byokEncryptKey.secret &&
  606.                 byokEncryptKey.iv!=null) {
  607.             encrypt = new Encrypt(byokEncryptKey.key, byokEncryptKey.iv);
  608.         }
  609.         else {
  610.             encrypt = new Encrypt(byokEncryptKey.key);
  611.         }
  612.         
  613.         if(byokEncryptKey.secret &&
  614.                 byokEncryptKey.iv==null) {
  615.             encrypt.initIV(config.getContentAlgorithm());
  616.         }
  617.         
  618.         byte [] encrypted = null;
  619.         try {
  620.             /**System.out.println("encrypt ["+config.getContentAlgorithm()+"]...");*/
  621.             encrypted = encrypt.encrypt(value, config.getContentAlgorithm());
  622.             /**System.out.println("encrypt ok");*/
  623.         }catch(Exception e) {
  624.             /**System.out.println("encrypt ERROR: "+e.getMessage());*/
  625.             throw new UtilsException(e.getMessage(),e);
  626.         }
  627.         
  628.         if(byokEncryptKey.secret &&
  629.                 byokEncryptKey.salt!=null){
  630.             encrypted = EncryptOpenSSLPass.formatOutput(byokEncryptKey.salt, encrypted);
  631.         }
  632.         
  633.         String en = null;
  634.         if(config.isBase64Encoding()) {
  635.             en = Base64Utilities.encodeAsString(encrypted);
  636.         }
  637.         else if(config.isHexEncoding()) {
  638.             en = HexBinaryUtilities.encodeAsString(encrypted);
  639.         }
  640.         else {
  641.             throw new UtilsException("Java algorithm undefined in keystore ["+config.getKeystoreType().getNome()+"] '"+config.getKeystorePath()+"'");
  642.         }
  643.         if(byokEncryptKey.secret) {
  644.             if(config.isBase64Encoding()) {
  645.                 return encrypt.getIVBase64AsString()+JAVA_SEPARATOR+en;
  646.             }
  647.             else {
  648.                 return encrypt.getIVHexBinaryAsString()+JAVA_SEPARATOR+en;
  649.             }
  650.         }
  651.         return en;
  652.     }
  653.     
  654.     private String encJavaKeyWrap(BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config, byte[] value) throws UtilsException {
  655.         
  656.         EncryptWrapKey encrypt = null;
  657.         if(byokEncryptKey.ks!=null) {
  658.             encrypt = new EncryptWrapKey(byokEncryptKey.ks, config.getKeyAlias());
  659.         }
  660.         else {
  661.             encrypt = new EncryptWrapKey(byokEncryptKey.key);
  662.         }
  663.                 
  664.         byte [] encrypted = null;
  665.         try {
  666.             /**System.out.println("encrypt ["+config.getKeyAlgorithm()+"] ["+config.getContentAlgorithm()+"]...");*/
  667.             encrypted = encrypt.encrypt(value, config.getKeyAlgorithm(), config.getContentAlgorithm());
  668.             /**System.out.println("encrypt ok");*/
  669.         }catch(Exception e) {
  670.             /**System.out.println("encrypt ERROR: "+e.getMessage());*/
  671.             throw new UtilsException(e.getMessage(),e);
  672.         }
  673.         
  674.         String en = null;
  675.         if(config.isBase64Encoding()) {
  676.             en = Base64Utilities.encodeAsString(encrypted);
  677.         }
  678.         else if(config.isHexEncoding()) {
  679.             en = HexBinaryUtilities.encodeAsString(encrypted);
  680.         }
  681.         else {
  682.             throw new UtilsException("Java algorithm undefined in keystore ["+config.getKeystoreType().getNome()+"] '"+config.getKeystorePath()+"'");
  683.         }

  685.         if(config.isBase64Encoding()) {
  686.             return encrypt.getWrappedKeyBase64()+JAVA_SEPARATOR+encrypt.getIVBase64AsString()+JAVA_SEPARATOR+en;
  687.         }
  688.         else {
  689.             return encrypt.getWrappedKeyHexBinary()+JAVA_SEPARATOR+encrypt.getIVHexBinaryAsString()+JAVA_SEPARATOR+en;
  690.         }
  691.         
  692.     }
  693.     
  694.     private String encJose(BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config, byte[] value) throws UtilsException {
  695.         JsonEncrypt encrypt = null;
  696.         JwtHeaders jwtHeaders = null;
  697.         JWEOptions options = new JWEOptions(JOSESerialization.COMPACT);
  698.         if(byokEncryptKey.ks!=null) {
  699.             jwtHeaders = this.getJwtHeaders(config, byokEncryptKey.ks);
  700.             if(byokEncryptKey.secret) {
  701.                 encrypt = new JsonEncrypt(byokEncryptKey.ks, config.getKeyAlias(), config.getKeyPassword(), config.getKeyAlgorithm(), config.getContentAlgorithm(),
  702.                         jwtHeaders, options); 
  703.             }
  704.             else {
  705.                 encrypt = new JsonEncrypt(byokEncryptKey.ks, config.getKeyAlias(), config.getKeyAlgorithm(), config.getContentAlgorithm(),
  706.                         jwtHeaders, options); 
  707.             }
  708.         }
  709.         else {
  710.             jwtHeaders = this.getJwtHeaders(config, byokEncryptKey.jsonWebKeys);
  711.             encrypt = new JsonEncrypt(byokEncryptKey.jsonWebKeys, byokEncryptKey.secret, config.getKeyAlias(), config.getKeyAlgorithm(), config.getContentAlgorithm(),
  712.                     jwtHeaders, options); 
  713.         }
  714.         return encrypt.encrypt(value);
  715.     }
  716.     
  717.     private JwtHeaders getJwtHeaders(BYOKLocalConfig config, KeyStore ks) throws UtilsException {
  718.         return getJwtHeaders(config, ks, null);
  719.     }
  720.     private JwtHeaders getJwtHeaders(BYOKLocalConfig config, JsonWebKeys jsonWebKeys) throws UtilsException {
  721.         return getJwtHeaders(config, null, jsonWebKeys);
  722.     }
  723.     private JwtHeaders getJwtHeaders(BYOKLocalConfig config, KeyStore ks, JsonWebKeys jsonWebKeys) throws UtilsException {
  724.         JwtHeaders jwtHeaders = new JwtHeaders();
  725.         if(config.isJoseIncludeKeyId()) {
  726.             jwtHeaders.setKid(config.getKeyAlias());
  727.         }

  729.         if(config.isJoseIncludeCert()) {
  730.             jwtHeaders.setAddX5C(true);
  731.         }
  732.         if(config.isJoseIncludeCertSha1()) {
  733.             jwtHeaders.setX509IncludeCertSha1(true);
  734.         }
  735.         if(config.isJoseIncludeCertSha256()) {
  736.             jwtHeaders.setX509IncludeCertSha256(true);
  737.         }
  738.         if(ks!=null && (config.isJoseIncludeCert() || config.isJoseIncludeCertSha1 ()|| config.isJoseIncludeCertSha256())) {
  739.             Certificate cert = ks.getCertificate(config.getKeyAlias());
  740.             if(cert instanceof X509Certificate) {
  741.                 jwtHeaders.addX509cert((X509Certificate)cert);
  742.             }
  743.         }
  744.         
  745.         if(jsonWebKeys!=null && config.isJoseIncludePublicKey()) {
  746.             jwtHeaders.setJwKey(jsonWebKeys, config.getKeyAlias());
  747.         }
  748.         
  749.         return jwtHeaders;
  750.     }
  751.     
  752.     private String encOpenSSL(BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config, byte[] value) throws UtilsException {
  753.         if(BYOKCostanti.isOpenSSLPBKDF2PasswordDerivationKeyMode(byokEncryptKey.pwdKeyDerivationConfig.getPasswordEncryptionMode())) {
  754.             return encOpenSSLPBKDF2(byokEncryptKey, config, value);
  755.         }
  756.         else {
  757.             return encOpenSSLStandard(byokEncryptKey, config, value);
  758.         }
  759.     }
  760.     private String encOpenSSLStandard(BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config, byte[] value) throws UtilsException {
  761.         
  762.         SecretPasswordKeyDerivationConfig passwordKeyDerivationConfig = byokEncryptKey.pwdKeyDerivationConfig;
  763.         
  764.         EncryptOpenSSLPass encrypt = new EncryptOpenSSLPass(passwordKeyDerivationConfig.getPassword(), 
  765.                 OpenSSLEncryptionMode.toMode(passwordKeyDerivationConfig.getPasswordEncryptionMode()));
  766.         
  767.         if(config.isBase64Encoding()) {
  768.             return encrypt.encryptBase64AsString(value);
  769.         }
  770.         else if(config.isHexEncoding()) {
  771.             return encrypt.encryptHexBinaryAsString(value);
  772.         }
  773.         else {
  774.             throw new UtilsException(ENCODING_MODE_UNDEFINED);
  775.         }
  776.     }
  777.     private String encOpenSSLPBKDF2(BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config, byte[] value) throws UtilsException {
  778.         
  779.         SecretPasswordKeyDerivationConfig passwordKeyDerivationConfig = byokEncryptKey.pwdKeyDerivationConfig;
  780.         
  781.         EncryptOpenSSLPassPBKDF2 encrypt = new EncryptOpenSSLPassPBKDF2(passwordKeyDerivationConfig.getPassword(), 
  782.                 passwordKeyDerivationConfig.getPasswordIterator(), 
  783.                 OpenSSLEncryptionMode.toMode(passwordKeyDerivationConfig.getPasswordEncryptionMode()));
  784.         
  785.         if(config.isBase64Encoding()) {
  786.             return encrypt.encryptBase64AsString(value);
  787.         }
  788.         else if(config.isHexEncoding()) {
  789.             return encrypt.encryptHexBinaryAsString(value);
  790.         }
  791.         else {
  792.             throw new UtilsException(ENCODING_MODE_UNDEFINED);
  793.         }
  794.     }
  795.     
  796.     
  797.     
  798.     
  799.     private byte[] decryptJava(BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config, String value) throws UtilsException {
  800.         
  801.         Decrypt d = null;
  802.         byte[]dataEncrypted = null;
  803.         if(byokEncryptKey.secret) {
  804.             String [] tmp = value.split("\\.");
  805.             if(tmp==null || tmp.length!=2) {
  806.                 throw new UtilsException("Atteso formato iv.secret (enc)");
  807.             }
  808.             byte[]iv = null;
  809.             if(config.isBase64Encoding()) {
  810.                 iv = Base64Utilities.decode(tmp[0]);
  811.                 dataEncrypted = Base64Utilities.decode(tmp[1]);
  812.             }
  813.             else if(config.isHexEncoding()) {
  814.                 iv = HexBinaryUtilities.decode(tmp[0]);
  815.                 dataEncrypted = HexBinaryUtilities.decode(tmp[1]);
  816.             }
  817.             else {
  818.                 iv = tmp[0].getBytes(); 
  819.                 dataEncrypted = tmp[1].getBytes();
  820.             }
  821.             if(KeystoreType.PASSWORD_KEY_DERIVATION.equals(config.getKeystoreType())) {
  822.                 dataEncrypted = DecryptOpenSSLPass.extractCipherBytes(dataEncrypted);
  823.             }
  824.             d = new Decrypt(byokEncryptKey.key, iv);
  825.         }
  826.         else {
  827.             if(config.isBase64Encoding()) {
  828.                 dataEncrypted = Base64Utilities.decode(value);
  829.             }
  830.             else if(config.isHexEncoding()) {
  831.                 dataEncrypted = HexBinaryUtilities.decode(value);
  832.             }
  833.             else {
  834.                 dataEncrypted = value.getBytes();
  835.             }
  836.             d = new Decrypt(byokEncryptKey.key);
  837.         }
  838.         
  839.         return d.decrypt(dataEncrypted, config.getContentAlgorithm());
  840.     }
  841.     
  842.     private byte[] decryptJavaKeyWrap(BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config, String value) throws UtilsException {
  843.         String [] tmp = value.split("\\.");
  844.         if(tmp==null || tmp.length!=3) {
  845.             throw new UtilsException("Atteso formato wrappedKey.iv.secret ("+config.getEncoding()+")");
  846.         }
  847.         byte[]wrappedKey = null;
  848.         byte[]iv = null;
  849.         byte[]dataEncrypted = null;
  850.         if(config.isBase64Encoding()) {
  851.             wrappedKey = Base64Utilities.decode(tmp[0]);
  852.             iv = Base64Utilities.decode(tmp[1]);
  853.             dataEncrypted = Base64Utilities.decode(tmp[2]);
  854.         }
  855.         else if(config.isHexEncoding()) {
  856.             wrappedKey = HexBinaryUtilities.decode(tmp[0]);
  857.             iv = HexBinaryUtilities.decode(tmp[1]);
  858.             dataEncrypted = HexBinaryUtilities.decode(tmp[2]);
  859.         }
  860.         else {
  861.             wrappedKey = tmp[0].getBytes();
  862.             iv = tmp[1].getBytes();
  863.             dataEncrypted = tmp[2].getBytes();
  864.         }
  865.         
  866.         DecryptWrapKey d = new DecryptWrapKey(byokEncryptKey.key);
  867.         return d.decrypt(dataEncrypted, wrappedKey, iv, config.getKeyAlgorithm(), config.getContentAlgorithm());
  868.     }
  869.     
  870.     private byte[] decryptJose(BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config, String value) throws UtilsException {
  871.         JsonDecrypt decrypt = null;
  872.         JWTOptions options = new JWTOptions(JOSESerialization.COMPACT);
  873.         if(byokEncryptKey.ks!=null) {
  874.             decrypt = new JsonDecrypt(byokEncryptKey.ks, byokEncryptKey.secret, config.getKeyAlias(), config.getKeyPassword(), config.getKeyAlgorithm(), config.getContentAlgorithm(),
  875.                         options); 
  876.         }
  877.         else {
  878.             decrypt = new JsonDecrypt(byokEncryptKey.jsonWebKeys, byokEncryptKey.secret, config.getKeyAlias(), config.getKeyAlgorithm(), config.getContentAlgorithm(),
  879.                     options); 
  880.         }
  881.         decrypt.decrypt(value);
  882.         return decrypt.getDecodedPayloadAsByte();
  883.     }
  884.     
  885.     private byte[] decryptOpenSSL(BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config, String value) throws UtilsException {
  886.         if(BYOKCostanti.isOpenSSLPBKDF2PasswordDerivationKeyMode(byokEncryptKey.pwdKeyDerivationConfig.getPasswordEncryptionMode())) {
  887.             return decryptOpenSSLPBKDF2(byokEncryptKey, config, value);
  888.         }
  889.         else {
  890.             return decryptOpenSSLStandard(byokEncryptKey, config, value);
  891.         }
  892.     }
  893.     private byte[] decryptOpenSSLStandard(BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config, String value) throws UtilsException {
  894.         
  895.         SecretPasswordKeyDerivationConfig passwordKeyDerivationConfig = byokEncryptKey.pwdKeyDerivationConfig;
  896.         
  897.         DecryptOpenSSLPass decrypt = new DecryptOpenSSLPass(passwordKeyDerivationConfig.getPassword(), 
  898.                 OpenSSLEncryptionMode.toMode(passwordKeyDerivationConfig.getPasswordEncryptionMode()));
  899.         
  900.         if(config.isBase64Encoding()) {
  901.             return decrypt.decryptBase64(value);
  902.         }
  903.         else if(config.isHexEncoding()) {
  904.             return decrypt.decryptHexBinary(value);
  905.         }
  906.         else {
  907.             throw new UtilsException(ENCODING_MODE_UNDEFINED);
  908.         }
  909.     }
  910.     private byte[] decryptOpenSSLPBKDF2(BYOKEncryptKey byokEncryptKey, BYOKLocalConfig config, String value) throws UtilsException {
  911.         
  912.         SecretPasswordKeyDerivationConfig passwordKeyDerivationConfig = byokEncryptKey.pwdKeyDerivationConfig;
  913.         
  914.         DecryptOpenSSLPassPBKDF2 decrypt = new DecryptOpenSSLPassPBKDF2(passwordKeyDerivationConfig.getPassword(), 
  915.                 passwordKeyDerivationConfig.getPasswordIterator(), 
  916.                 OpenSSLEncryptionMode.toMode(passwordKeyDerivationConfig.getPasswordEncryptionMode()));
  917.         
  918.         if(config.isBase64Encoding()) {
  919.             return decrypt.decryptBase64(value);
  920.         }
  921.         else if(config.isHexEncoding()) {
  922.             return decrypt.decryptHexBinary(value);
  923.         }
  924.         else {
  925.             throw new UtilsException(ENCODING_MODE_UNDEFINED);
  926.         }
  927.     }
  928. }

  930. class BYOKEncryptKey{
  931.     Key key = null;
  932.     byte[]iv = null;
  933.     byte[]salt = null;
  934.     boolean secret = false;
  935.     KeyStore ks = null;
  936.     JsonWebKeys jsonWebKeys = null;
  937.     SecretPasswordKeyDerivationConfig pwdKeyDerivationConfig = null;
  938. }
Created with JaCoCo 0.8.8.202204050719