JOSEUtils.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.  */


  22. package org.openspcoop2.security.message.jose;

  24. import java.net.Proxy;
  25. import java.net.URI;
  26. import java.security.cert.Certificate;
  27. import java.security.cert.X509Certificate;
  28. import java.util.ArrayList;
  29. import java.util.Enumeration;
  30. import java.util.HashMap;
  31. import java.util.List;
  32. import java.util.Map;
  33. import java.util.Properties;

  35. import org.apache.commons.lang.StringUtils;
  36. import org.apache.cxf.rt.security.rs.RSSecurityConstants;
  37. import org.openspcoop2.core.commons.DBUtils;
  38. import org.openspcoop2.core.constants.CostantiConnettori;
  39. import org.openspcoop2.core.mvc.properties.utils.MultiPropertiesUtilities;
  40. import org.openspcoop2.message.OpenSPCoop2Message;
  41. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  42. import org.openspcoop2.security.SecurityException;
  43. import org.openspcoop2.security.keystore.BYOKUnwrapManager;
  44. import org.openspcoop2.security.keystore.CRLCertstore;
  45. import org.openspcoop2.security.keystore.HttpStore;
  46. import org.openspcoop2.security.keystore.KeyPairStore;
  47. import org.openspcoop2.security.keystore.MerlinKeystore;
  48. import org.openspcoop2.security.keystore.MerlinTruststore;
  49. import org.openspcoop2.security.keystore.PublicKeyStore;
  50. import org.openspcoop2.security.keystore.cache.GestoreKeystoreCache;
  51. import org.openspcoop2.security.message.constants.SecurityConstants;
  52. import org.openspcoop2.utils.LoggerWrapperFactory;
  53. import org.openspcoop2.utils.Utilities;
  54. import org.openspcoop2.utils.UtilsException;
  55. import org.openspcoop2.utils.certificate.JWKSet;
  56. import org.openspcoop2.utils.certificate.KeyStore;
  57. import org.openspcoop2.utils.certificate.KeystoreType;
  58. import org.openspcoop2.utils.certificate.KeystoreUtils;
  59. import org.openspcoop2.utils.certificate.byok.BYOKProvider;
  60. import org.openspcoop2.utils.certificate.byok.BYOKRequestParams;
  61. import org.openspcoop2.utils.certificate.remote.IRemoteStoreProvider;
  62. import org.openspcoop2.utils.certificate.remote.RemoteKeyType;
  63. import org.openspcoop2.utils.certificate.remote.RemoteStoreConfig;
  64. import org.openspcoop2.utils.security.JOSESerialization;
  65. import org.openspcoop2.utils.security.JWTOptions;
  66. import org.openspcoop2.utils.security.JwtHeaders;
  67. import org.openspcoop2.utils.transport.http.HttpForwardProxyConfig;
  68. import org.openspcoop2.utils.transport.http.HttpForwardProxyOptions;
  69. import org.openspcoop2.utils.transport.http.HttpOptions;
  70. import org.openspcoop2.utils.transport.http.HttpProxyOptions;
  71. import org.openspcoop2.utils.transport.http.HttpsOptions;
  72. import org.slf4j.Logger;

  74. /**     
  75.  * JOSEUtils
  76.  *
  77.  * @author Poli Andrea (poli@link.it)
  78.  * @author $Author$
  79.  * @version $Rev$, $Date$
  80.  */
  81. public class JOSEUtils {

  83.     private JOSEUtils() {}
  84.     
  85.     public static JOSESerialization toJOSESerialization(String mode) throws SecurityException {
  86.         if(SecurityConstants.SIGNATURE_MODE_JSON.equals(mode)) {
  87.             return JOSESerialization.JSON;
  88.         }
  89.         else if(SecurityConstants.SIGNATURE_MODE_COMPACT.equals(mode)) {
  90.             return JOSESerialization.COMPACT;
  91.         } 
  92.         else {
  93.             throw new SecurityException("Mode '"+mode+"' unsupported");
  94.         }
  95.     }
  96.     
  97.     public static JwtHeaders getJwtHeaders(Map<String, Object> properties, OpenSPCoop2Message message) throws SecurityException {
  98.         return getJwtHeaders(properties, message, null, null, null);
  99.     }
  100.     public static JwtHeaders getJwtHeaders(Map<String, Object> properties, OpenSPCoop2Message message,
  101.             String alias) throws SecurityException {
  102.         return getJwtHeaders(properties, message, alias, null, null);
  103.     }
  104.     public static JwtHeaders getJwtHeaders(Map<String, Object> properties, OpenSPCoop2Message message,
  105.             String alias, JWKSet jwkSet) throws SecurityException {
  106.         return getJwtHeaders(properties, message, alias, jwkSet, null);
  107.     }
  108.     public static JwtHeaders getJwtHeaders(Map<String, Object> properties, OpenSPCoop2Message message,
  109.             String alias, KeyStore keystore) throws SecurityException {
  110.         return getJwtHeaders(properties, message, alias, null, keystore);
  111.     }
  112.     private static JwtHeaders getJwtHeaders(Map<String, Object> properties, OpenSPCoop2Message message,
  113.             String alias, JWKSet jwkSet, 
  114.             KeyStore keystore) throws SecurityException {
  115.         JwtHeaders hdrs = new JwtHeaders();
  116.         
  117.         if(properties.containsKey(SecurityConstants.JOSE_KID)) {
  118.             String value = (String) properties.get(SecurityConstants.JOSE_KID);
  119.             if(value!=null) {
  120.                 value = value.trim();
  121.             }
  122.             if(SecurityConstants.JOSE_KID_TRUE.equalsIgnoreCase(value)) {
  123.                 hdrs.setKid(alias);
  124.             }
  125.         }
  126.         else if(properties.containsKey(SecurityConstants.JOSE_KID_CUSTOM)) {
  127.             String value = (String) properties.get(SecurityConstants.JOSE_KID_CUSTOM);
  128.             if(value!=null) {
  129.                 value = value.trim();
  130.                 hdrs.setKid(value);
  131.             }
  132.         }
  133.         
  134.         if(properties.containsKey(SecurityConstants.JOSE_INCLUDE_CERT)) {
  135.             String value = (String) properties.get(SecurityConstants.JOSE_INCLUDE_CERT);
  136.             if(value!=null) {
  137.                 value = value.trim();
  138.             }
  139.             if(SecurityConstants.JOSE_INCLUDE_CERT_TRUE.equalsIgnoreCase(value)) {
  140.                 try {
  141.                     if(alias==null) {
  142.                         throw new SecurityException("Alias undefined (required for include cert)");
  143.                     }
  144.                     if(jwkSet!=null) {
  145.                         hdrs.setJwKey(jwkSet.getJsonWebKeys(), alias);
  146.                     }
  147.                     else if(keystore!=null) {
  148.                         
  149.                         boolean certChain = false;
  150.                         if(properties.containsKey(SecurityConstants.JOSE_INCLUDE_CERT_CHAIN)) {
  151.                             String valueChain = (String) properties.get(SecurityConstants.JOSE_INCLUDE_CERT_CHAIN);
  152.                             if(valueChain!=null) {
  153.                                 valueChain = valueChain.trim();
  154.                             }
  155.                             if(SecurityConstants.JOSE_INCLUDE_CERT_CHAIN_TRUE.equalsIgnoreCase(valueChain)) {
  156.                                 certChain = true;
  157.                             }
  158.                         }
  159.                         
  160.                         /**
  161.                         System.out.println("\n\n==============================================");
  162.                         System.out.println("ALIAS: ["+alias+"]");
  163.                         Certificate[] chain = keystore.getCertificateChain(alias);
  164.                         if(chain!=null) {
  165.                             System.out.println("CHAINS: ["+chain.length+"]");
  166.                         }
  167.                         for (int i = 0; i < chain.length; i++) {
  168.                             System.out.println("CHAIN["+i+"]: ["+(((X509Certificate)chain[i]).getSubjectX500Principal().toString()+"]"));
  169.                         }
  170.                         System.out.println("CERT: ["+(((X509Certificate)keystore.getCertificate(alias)).getSubjectX500Principal().toString()+"]"));
  171.                         */
  172.                         if(certChain) {
  173.                             Certificate[] certificateChain = keystore.getCertificateChain(alias);
  174.                             if(certificateChain!=null && certificateChain.length>0) {
  175.                                 for (int i = 0; i < certificateChain.length; i++) {
  176.                                     hdrs.addX509cert((X509Certificate)certificateChain[i]);
  177.                                 }
  178.                             }
  179.                             else {
  180.                                 hdrs.addX509cert((X509Certificate)keystore.getCertificate(alias));
  181.                             }
  182.                         }
  183.                         else {
  184.                             hdrs.addX509cert((X509Certificate)keystore.getCertificate(alias));
  185.                         }
  186.                         hdrs.setAddX5C(true);
  187.                     }
  188.                 }catch(Exception e) {
  189.                     throw new SecurityException(e.getMessage(),e);
  190.                 }
  191.             }
  192.         }
  193.         
  194.         if(properties.containsKey(SecurityConstants.JOSE_INCLUDE_CERT_SHA)) {
  195.             String value = (String) properties.get(SecurityConstants.JOSE_INCLUDE_CERT_SHA);
  196.             if(value!=null) {
  197.                 value = value.trim();
  198.             }
  199.             if(hdrs.getX509c()==null || hdrs.getX509c().isEmpty()) {
  200.                 if(keystore==null) {
  201.                     throw new SecurityException("Keystore undefined (required for digest '"+value+"')");
  202.                 }
  203.                 if(alias==null) {
  204.                     throw new SecurityException("Alias undefined (required for digest '"+value+"')");
  205.                 }
  206.                 Certificate cert = null;
  207.                 try {
  208.                     cert = keystore.getCertificate(alias);
  209.                 }catch(Exception e) {
  210.                     throw new SecurityException(e.getMessage(),e);
  211.                 }
  212.                 if(cert==null) {
  213.                     throw new SecurityException("Certificate with alias '"+alias+"' not found (required for digest '"+value+"')");
  214.                 }
  215.                 hdrs.addX509cert((X509Certificate)cert);
  216.             }
  217.             if(SecurityConstants.JOSE_INCLUDE_CERT_SHA_1.equalsIgnoreCase(value)) {
  218.                 try {
  219.                     hdrs.setX509IncludeCertSha1(true);
  220.                 }catch(Exception e) {
  221.                     throw new SecurityException(e.getMessage(),e);
  222.                 }
  223.             }
  224.             else if(SecurityConstants.JOSE_INCLUDE_CERT_SHA_256.equalsIgnoreCase(value)) {
  225.                 try {
  226.                     hdrs.setX509IncludeCertSha256(true);
  227.                 }catch(Exception e) {
  228.                     throw new SecurityException(e.getMessage(),e);
  229.                 }
  230.             }
  231.             else {
  232.                 throw new SecurityException("Value '"+value+"' unknowkn for property '"+SecurityConstants.JOSE_INCLUDE_CERT_SHA+"'");
  233.             }
  234.         }
  235.         
  236.         if(properties.containsKey(SecurityConstants.JOSE_CONTENT_TYPE)) {
  237.             String value = (String) properties.get(SecurityConstants.JOSE_CONTENT_TYPE);
  238.             if(value!=null) {
  239.                 value = value.trim();
  240.             }
  241.             if(SecurityConstants.JOSE_CONTENT_TYPE_TRUE.equalsIgnoreCase(value)) {
  242.                 try {
  243.                     hdrs.setContentType(message.getContentType());
  244.                 }catch(Exception e) {
  245.                     throw new SecurityException(e.getMessage(),e);
  246.                 }
  247.             }
  248.         }
  249.         
  250.         if(properties.containsKey(SecurityConstants.JOSE_TYPE)) {
  251.             String value = (String) properties.get(SecurityConstants.JOSE_TYPE);
  252.             if(value!=null) {
  253.                 value = value.trim();
  254.             }
  255.             if(value!=null && !StringUtils.isEmpty(value)) {
  256.                 hdrs.setType(value);
  257.             }
  258.         }
  259.         
  260.         if(properties.containsKey(SecurityConstants.JOSE_X509_URL)) {
  261.             String value = (String) properties.get(SecurityConstants.JOSE_X509_URL);
  262.             if(value!=null) {
  263.                 value = value.trim();
  264.             }
  265.             if(value!=null && !StringUtils.isEmpty(value)) {
  266.                 try {
  267.                     hdrs.setX509Url(new URI(value));
  268.                 }catch(Exception e) {
  269.                     throw new SecurityException(e.getMessage(),e);
  270.                 }
  271.             }
  272.         }
  273.         
  274.         if(properties.containsKey(SecurityConstants.JOSE_JWK_SET_URL)) {
  275.             String value = (String) properties.get(SecurityConstants.JOSE_JWK_SET_URL);
  276.             if(value!=null) {
  277.                 value = value.trim();
  278.             }
  279.             if(value!=null && !StringUtils.isEmpty(value)) {
  280.                 try {
  281.                     hdrs.setJwkUrl(new URI(value));
  282.                 }catch(Exception e) {
  283.                     throw new SecurityException(e.getMessage(),e);
  284.                 }
  285.             }
  286.         }
  287.         
  288.         if(properties.containsKey(SecurityConstants.JOSE_CRITICAL_HEADERS)) {
  289.             String value = (String) properties.get(SecurityConstants.JOSE_CRITICAL_HEADERS);
  290.             if(value!=null) {
  291.                 value = value.trim();
  292.             }
  293.             if(value!=null && !StringUtils.isEmpty(value)) {
  294.                 if(value.contains(SecurityConstants.JOSE_CRITICAL_HEADERS_SEPARATOR)) {
  295.                     String [] tmp = value.split(SecurityConstants.JOSE_CRITICAL_HEADERS_SEPARATOR);
  296.                     for (String v : tmp) {
  297.                         if(v!=null) {
  298.                             v = v.trim();
  299.                             if(!StringUtils.isEmpty(v)) {
  300.                                 hdrs.addCriticalHeader(v);
  301.                             }
  302.                         }
  303.                     }
  304.                 }
  305.                 else {
  306.                     hdrs.addCriticalHeader(value);
  307.                 }
  308.             }
  309.         }
  310.         
  311.         try {
  312.             Properties pConvert = new Properties();
  313.             pConvert.putAll(properties);
  314.             Properties pExts = Utilities.readProperties(SecurityConstants.JOSE_EXT_HEADER_PREFIX, pConvert);
  315.             if(pExts!=null && pExts.size()>0) {
  316.                 Enumeration<?> names = pExts.propertyNames();
  317.                 while (names.hasMoreElements()) {
  318.                     Object oName = names.nextElement();
  319.                     if(oName instanceof String) {
  320.                         String name = (String) oName;
  321.                         if(name!=null) {
  322.                             name = name.trim();
  323.                             if(name.endsWith(SecurityConstants.JOSE_EXT_HEADER_SUFFIX_NAME)) {
  324.                                 String hdrName = pExts.getProperty(name);
  325.                                 String confName = name.substring(0, name.indexOf(SecurityConstants.JOSE_EXT_HEADER_SUFFIX_NAME));
  326.                                 String nameValue = confName+SecurityConstants.JOSE_EXT_HEADER_SUFFIX_VALUE;
  327.                                 String hdrValue = pExts.getProperty(nameValue);
  328.                                 if(hdrValue==null) {
  329.                                     throw new SecurityException("Property '"+SecurityConstants.JOSE_EXT_HEADER_PREFIX+nameValue+"' not found");
  330.                                 }
  331.                                 hdrs.addExtension(hdrName, hdrValue);
  332.                             }
  333.                         }
  334.                     }
  335.                 }
  336.             }
  337.         }catch(Exception e) {
  338.             throw new SecurityException(e.getMessage(),e);
  339.         }
  340.         
  341.         return hdrs;
  342.         
  343.         
  344.     }

  346.     
  347.     public static boolean useJwtHeadersMapProperties(Map<String, Properties> properties, JWTOptions options) {
  348.         Properties defaultProperties = MultiPropertiesUtilities.getDefaultProperties(properties);
  349.         return useJwtHeaders(defaultProperties, options);
  350.     }
  351.     public static boolean useJwtHeadersMap(Map<String, Object> propertiesParam, JWTOptions options) {
  352.         Properties properties = new Properties();
  353.         properties.putAll(propertiesParam);
  354.         return useJwtHeaders(properties, options);
  355.     }
  356.     public static boolean useJwtHeaders(Properties properties, JWTOptions options) {
  357.     
  358.         boolean useJwtHeaders = false;
  359.         if(properties.containsKey(SecurityConstants.JOSE_USE_HEADERS)) {
  360.             String value = (String) properties.get(SecurityConstants.JOSE_USE_HEADERS);
  361.             if(value!=null) {
  362.                 value = value.trim();
  363.                 useJwtHeaders = SecurityConstants.JOSE_USE_HEADERS_TRUE.equalsIgnoreCase(value);
  364.             }
  365.             
  366.             if(useJwtHeaders) {
  367.                 
  368.                 if(properties.containsKey(SecurityConstants.JOSE_USE_HEADERS_X5C)) {
  369.                     value = (String) properties.get(SecurityConstants.JOSE_USE_HEADERS_X5C);
  370.                     if(value!=null) {
  371.                         value = value.trim();
  372.                         options.setPermitUseHeaderX5C(SecurityConstants.JOSE_USE_HEADERS_TRUE.equalsIgnoreCase(value));
  373.                     }
  374.                 }
  375.                 
  376.                 if(properties.containsKey(SecurityConstants.JOSE_USE_HEADERS_X5U)) {
  377.                     value = (String) properties.get(SecurityConstants.JOSE_USE_HEADERS_X5U);
  378.                     if(value!=null) {
  379.                         value = value.trim();
  380.                         options.setPermitUseHeaderX5U(SecurityConstants.JOSE_USE_HEADERS_TRUE.equalsIgnoreCase(value));
  381.                     }
  382.                 }
  383.                 
  384.                 if(properties.containsKey(SecurityConstants.JOSE_USE_HEADERS_X5T)) {
  385.                     value = (String) properties.get(SecurityConstants.JOSE_USE_HEADERS_X5T);
  386.                     if(value!=null) {
  387.                         value = value.trim();
  388.                         options.setPermitUseHeaderX5T(SecurityConstants.JOSE_USE_HEADERS_TRUE.equalsIgnoreCase(value));
  389.                     }
  390.                 }
  391.                 
  392.                 if(properties.containsKey(SecurityConstants.JOSE_USE_HEADERS_X5T_256)) {
  393.                     value = (String) properties.get(SecurityConstants.JOSE_USE_HEADERS_X5T_256);
  394.                     if(value!=null) {
  395.                         value = value.trim();
  396.                         options.setPermitUseHeaderX5T_256(SecurityConstants.JOSE_USE_HEADERS_TRUE.equalsIgnoreCase(value));
  397.                     }
  398.                 }
  399.                 
  400.                 if(properties.containsKey(SecurityConstants.JOSE_USE_HEADERS_JWK)) {
  401.                     value = (String) properties.get(SecurityConstants.JOSE_USE_HEADERS_JWK);
  402.                     if(value!=null) {
  403.                         value = value.trim();
  404.                         options.setPermitUseHeaderJWK(SecurityConstants.JOSE_USE_HEADERS_TRUE.equalsIgnoreCase(value));
  405.                     }
  406.                 }
  407.                 
  408.                 if(properties.containsKey(SecurityConstants.JOSE_USE_HEADERS_JKU)) {
  409.                     value = (String) properties.get(SecurityConstants.JOSE_USE_HEADERS_JKU);
  410.                     if(value!=null) {
  411.                         value = value.trim();
  412.                         options.setPermitUseHeaderJKU(SecurityConstants.JOSE_USE_HEADERS_TRUE.equalsIgnoreCase(value));
  413.                     }
  414.                 }
  415.                 
  416.                 if(properties.containsKey(SecurityConstants.JOSE_USE_HEADERS_KID)) {
  417.                     value = (String) properties.get(SecurityConstants.JOSE_USE_HEADERS_KID);
  418.                     if(value!=null) {
  419.                         value = value.trim();
  420.                         options.setPermitUseHeaderKID(SecurityConstants.JOSE_USE_HEADERS_TRUE.equalsIgnoreCase(value));
  421.                     }
  422.                 }
  423.                 
  424.             }
  425.         }
  426.         
  427.         return useJwtHeaders;
  428.     }
  429.     

  431.     public static Properties toSslConfigJwtUrlHeader(Map<String, Object> propertiesParam) {
  432.         Properties properties = null;
  433.         if(propertiesParam.containsKey(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_SSL_FILE)) {
  434.             String keystoreFile = (String) propertiesParam.get(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_SSL_FILE);
  435.             if(keystoreFile!=null) {
  436.                 
  437.                 properties = new Properties();
  438.                 
  439.                 properties.put(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_SSL_FILE, keystoreFile);
  440.                 
  441.                 String keystoreType = (String) propertiesParam.get(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_SSL_TYPE);
  442.                 if(keystoreType!=null) {
  443.                     properties.put(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_SSL_TYPE, keystoreType);
  444.                 }
  445.                 
  446.                 String keystorePassword = (String) propertiesParam.get(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_SSL_PASSWORD);
  447.                 if(keystorePassword!=null) {
  448.                     properties.put(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_SSL_PASSWORD, keystorePassword);
  449.                 }
  450.             }
  451.         }
  452.         return properties;
  453.     }
  454.     public static KeyStore readTrustStoreSsl(RequestInfo requestInfo, Map<String, Object> propertiesParam) throws SecurityException {
  455.         Properties properties = new Properties();
  456.         properties.putAll(propertiesParam);
  457.         return readTrustStoreSsl(requestInfo, properties);
  458.     }
  459.     public static KeyStore readTrustStoreSsl(RequestInfo requestInfo, Properties properties) throws SecurityException {
  460.         return readTrustStoreEngine(requestInfo, properties, SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_SSL_FILE, 
  461.                 SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_SSL_TYPE, 
  462.                 SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_SSL_PASSWORD);
  463.     }

  465.     public static KeyStore readTrustStoreJwtX509Cert(RequestInfo requestInfo, Map<String, Object> propertiesParam) throws SecurityException {
  466.         Properties properties = new Properties();
  467.         properties.putAll(propertiesParam);
  468.         return readTrustStoreJwtX509Cert(requestInfo, properties);
  469.     }
  470.     public static KeyStore readTrustStoreJwtX509Cert(RequestInfo requestInfo, Properties properties) throws SecurityException {
  471.         return readTrustStoreEngine(requestInfo, properties, SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_FILE, 
  472.                 SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_TYPE, 
  473.                 SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_PASSWORD);
  474.     }

  476.     public static boolean isJWKSetTrustStore(Map<String, Object> propertiesParam) {
  477.         Properties properties = new Properties();
  478.         properties.putAll(propertiesParam);
  479.         return isJWKSetTrustStore(properties);
  480.     }
  481.     public static boolean isJWKSetTrustStore(Properties properties) {
  482.         if(properties.containsKey(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_TYPE)) {
  483.             String truststoreType = (String) properties.get(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_TYPE);
  484.             if(truststoreType!=null) {
  485.                 return SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(truststoreType);
  486.             }
  487.         }
  488.         return false;
  489.     }
  490.         
  491.     public static JWKSet readTrustStoreJwtJsonWebKeysCert(RequestInfo requestInfo, Map<String, Object> propertiesParam) throws SecurityException {
  492.         Properties properties = new Properties();
  493.         properties.putAll(propertiesParam);
  494.         return readTrustStoreJwtJsonWebKeysCert(requestInfo, properties);
  495.     }
  496.     public static JWKSet readTrustStoreJwtJsonWebKeysCert(RequestInfo requestInfo, Properties properties) throws SecurityException {
  497.         
  498.         if(properties.containsKey(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_FILE)) {
  499.             String truststoreFile = (String) properties.get(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_FILE);
  500.             if(truststoreFile!=null) {
  501.                 truststoreFile = truststoreFile.trim();
  502.             }
  503.             else {
  504.                 throw new SecurityException("Truststore value in property '"+SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_FILE+"' is null");
  505.             }
  506.             try {
  507.                 return GestoreKeystoreCache.getJwkSetStore(requestInfo, truststoreFile).getJwkSet();
  508.             }catch(Exception e) {
  509.                 throw new SecurityException(e.getMessage(),e);
  510.             }
  511.         }
  512.         
  513.         return null;
  514.     }
  515.     
  516.     public static boolean isPublicKeyTrustStore(Map<String, Object> propertiesParam) {
  517.         Properties properties = new Properties();
  518.         properties.putAll(propertiesParam);
  519.         return isPublicKeyTrustStore(properties);
  520.     }
  521.     public static boolean isPublicKeyTrustStore(Properties properties) {
  522.         if(properties.containsKey(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_TYPE)) {
  523.             String truststoreType = (String) properties.get(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_TYPE);
  524.             if(truststoreType!=null) {
  525.                 return SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(truststoreType);
  526.             }
  527.         }
  528.         return false;
  529.     }
  530.     
  531.     public static JWKSet readTrustStorePublicKey(RequestInfo requestInfo, Map<String, Object> propertiesParam) throws SecurityException {
  532.         Properties properties = new Properties();
  533.         properties.putAll(propertiesParam);
  534.         return readTrustStorePublicKey(requestInfo, properties);
  535.     }
  536.     public static JWKSet readTrustStorePublicKey(RequestInfo requestInfo, Properties properties) throws SecurityException {
  537.         
  538.         if(properties.containsKey(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_FILE)) {
  539.             String truststoreFile = (String) properties.get(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_FILE);
  540.             if(truststoreFile!=null) {
  541.                 truststoreFile = truststoreFile.trim();
  542.             }
  543.             else {
  544.                 throw new SecurityException("Truststore value in property '"+SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_FILE+"' is null");
  545.             }
  546.             String truststoreAlgo = (String) properties.get(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_KEY_PAIR_ALGORITHM);
  547.             if(truststoreAlgo!=null) {
  548.                 truststoreAlgo = truststoreAlgo.trim();
  549.             }
  550.             else {
  551.                 throw new SecurityException("Key algorithm value in property '"+SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_KEY_PAIR_ALGORITHM+"' is null");
  552.             }
  553.             try {
  554.                 return GestoreKeystoreCache.getPublicKeyStore(requestInfo, truststoreFile, truststoreAlgo).getJwkSet();
  555.             }catch(Exception e) {
  556.                 throw new SecurityException(e.getMessage(),e);
  557.             }
  558.         }
  559.         
  560.         return null;
  561.     }
  562.     
  563.     public static boolean isRemoteStore(Map<String, Object> propertiesParam) {
  564.         Properties properties = new Properties();
  565.         properties.putAll(propertiesParam);
  566.         return isRemoteStore(properties);
  567.     }
  568.     public static boolean isRemoteStore(Properties properties) {
  569.         try {
  570.             IRemoteStoreProvider provider = null; 
  571.             if(properties.containsKey(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_REMOTE_STORE_PROVIDER)) {
  572.                 provider = (IRemoteStoreProvider) properties.get(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_REMOTE_STORE_PROVIDER);
  573.             }
  574.             
  575.             RemoteKeyType keyType = null; 
  576.             if(properties.containsKey(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_REMOTE_STORE_KEY_TYPE)) {
  577.                 keyType = (RemoteKeyType) properties.get(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_REMOTE_STORE_KEY_TYPE);
  578.             }
  579.             
  580.             RemoteStoreConfig config = null; 
  581.             if(properties.containsKey(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_REMOTE_STORE_CONFIG)) {
  582.                 config = (RemoteStoreConfig) properties.get(SecurityConstants.JOSE_USE_HEADERS_TRUSTSTORE_REMOTE_STORE_CONFIG);
  583.             }
  584.             
  585.             return provider!=null && keyType!=null && config!=null;
  586.             
  587.         }catch(Exception e) {
  588.             return false;
  589.         }
  590.         
  591.     }
  592.     
  593.     
  594.     public static boolean isKeyPairKeystore(Map<String, Object> propertiesParam) {
  595.         Properties properties = new Properties();
  596.         properties.putAll(propertiesParam);
  597.         return isKeyPairKeystore(properties);
  598.     }
  599.     public static boolean isKeyPairKeystore(Properties properties) {
  600.         if(properties.containsKey(SecurityConstants.JOSE_USE_HEADERS_KEYSTORE_TYPE)) {
  601.             String keystoreType = (String) properties.get(SecurityConstants.JOSE_USE_HEADERS_KEYSTORE_TYPE);
  602.             if(keystoreType!=null) {
  603.                 return SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType);
  604.             }
  605.         }
  606.         return false;
  607.     }
  608.     
  609.     public static boolean isJWKSetKeyStore(Map<String, Object> propertiesParam) {
  610.         Properties properties = new Properties();
  611.         properties.putAll(propertiesParam);
  612.         return isJWKSetKeyStore(properties);
  613.     }
  614.     public static boolean isJWKSetKeyStore(Properties properties) {
  615.         if(properties.containsKey(SecurityConstants.JOSE_USE_HEADERS_KEYSTORE_TYPE)) {
  616.             String truststoreType = (String) properties.get(SecurityConstants.JOSE_USE_HEADERS_KEYSTORE_TYPE);
  617.             if(truststoreType!=null) {
  618.                 return SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(truststoreType);
  619.             }
  620.         }
  621.         return false;
  622.     }
  623.     
  624.     public static JWKSet readKeyStoreJwtJsonWebKeysCert(RequestInfo requestInfo, Map<String, Object> propertiesParam) throws SecurityException {
  625.         Properties properties = new Properties();
  626.         properties.putAll(propertiesParam);
  627.         return readKeyStoreJwtJsonWebKeysCert(requestInfo, properties);
  628.     }
  629.     public static JWKSet readKeyStoreJwtJsonWebKeysCert(RequestInfo requestInfo, Properties properties) throws SecurityException {
  630.         
  631.         if(properties.containsKey(SecurityConstants.JOSE_USE_HEADERS_KEYSTORE_FILE)) {
  632.             String keystoreFile = (String) properties.get(SecurityConstants.JOSE_USE_HEADERS_KEYSTORE_FILE);
  633.             if(keystoreFile!=null) {
  634.                 keystoreFile = keystoreFile.trim();
  635.             }
  636.             else {
  637.                 throw new SecurityException("Keystore value in property '"+SecurityConstants.JOSE_USE_HEADERS_KEYSTORE_FILE+"' is null");
  638.             }
  639.             try {
  640.                 return GestoreKeystoreCache.getJwkSetStore(requestInfo, keystoreFile).getJwkSet();
  641.             }catch(Exception e) {
  642.                 throw new SecurityException(e.getMessage(),e);
  643.             }
  644.         }
  645.         
  646.         return null;
  647.     }
  648.         
  649.     public static KeyStore readKeyStoreJwtX509Cert(RequestInfo requestInfo, Map<String, Object> propertiesParam) throws SecurityException {
  650.         Properties properties = new Properties();
  651.         properties.putAll(propertiesParam);
  652.         return readKeyStoreJwtX509Cert(requestInfo, properties);
  653.     }
  654.     public static KeyStore readKeyStoreJwtX509Cert(RequestInfo requestInfo, Properties properties) throws SecurityException {
  655.         return readTrustStoreEngine(requestInfo, properties, SecurityConstants.JOSE_USE_HEADERS_KEYSTORE_FILE, 
  656.                 SecurityConstants.JOSE_USE_HEADERS_KEYSTORE_TYPE, 
  657.                 SecurityConstants.JOSE_USE_HEADERS_KEYSTORE_PASSWORD);
  658.     }
  659.     
  660.     public static Map<String, String> covertToJwtX509CertMapAliasPassword(Map<String, Object> propertiesParam) throws SecurityException, UtilsException {
  661.         Properties properties = new Properties();
  662.         properties.putAll(propertiesParam);
  663.         return readJwtX509CertMapAliasPassword(properties);
  664.     }
  665.     public static Map<String, String> readJwtX509CertMapAliasPassword(Properties properties) throws SecurityException, UtilsException {
  666.         try {
  667.             HashMap<String, String> map = new HashMap<>();
  668.             Properties pMap = Utilities.readProperties(SecurityConstants.JOSE_USE_HEADERS_KEYSTORE_MAP_ALIAS_PW, properties);
  669.             if(pMap!=null && pMap.size()>0) {
  670.                 Enumeration<?> names = pMap.propertyNames();
  671.                 while (names.hasMoreElements()) {
  672.                     Object oName = names.nextElement();
  673.                     if(oName instanceof String) {
  674.                         String name = (String) oName;
  675.                         name = name.trim();
  676.                         if(name.endsWith(SecurityConstants.JOSE_USE_HEADERS_KEYSTORE_MAP_ALIAS_PW_SUFFIX_ALIAS)) {
  677.                             String alias = pMap.getProperty(name);
  678.                             String confName = name.substring(0, name.indexOf(SecurityConstants.JOSE_USE_HEADERS_KEYSTORE_MAP_ALIAS_PW_SUFFIX_ALIAS));
  679.                             String namePassword = confName+SecurityConstants.JOSE_USE_HEADERS_KEYSTORE_MAP_ALIAS_PW_SUFFIX_PW;
  680.                             String password = pMap.getProperty(namePassword);
  681.                             if(password==null) {
  682.                                 throw new SecurityException("Property '"+SecurityConstants.JOSE_USE_HEADERS_KEYSTORE_MAP_ALIAS_PW+namePassword+"' not found");
  683.                             }
  684.                             map.put(alias, password);
  685.                         }
  686.                     }
  687.                 }
  688.             }
  689.             if(!map.isEmpty()) {
  690.                 return map;
  691.             }
  692.             else {
  693.                 return null;
  694.             }
  695.         }catch(Exception e) {
  696.             throw new SecurityException(e.getMessage(),e);
  697.         }
  698.     }
  699.         
  700.     private static KeyStore readTrustStoreEngine(RequestInfo requestInfo, Properties properties, String file, String type, String password) throws SecurityException {
  701.         
  702.         KeyStore keystore = null;
  703.         
  704.         String requiredPropertyPrefix = "Required property '";
  705.         
  706.         if(properties.containsKey(file)) {
  707.             String keystoreFile = (String) properties.get(file);
  708.             if(keystoreFile!=null) {
  709.                 keystoreFile = keystoreFile.trim();
  710.                 
  711.                 if(!properties.containsKey(type)) {
  712.                     throw new SecurityException(requiredPropertyPrefix+type+"' not found");
  713.                 }
  714.                 String keystoreType = (String) properties.get(type);
  715.                 if(keystoreType==null) {
  716.                     throw new SecurityException(requiredPropertyPrefix+type+"' is empty");
  717.                 }
  718.                 keystoreType = keystoreType.trim();
  719.                 
  720.                 boolean requiredPassword = true;
  721.                 if(!properties.containsKey(password)) {
  722.                     if(
  723.                             (KeystoreType.JKS.isType(keystoreType) && !DBUtils.isTruststoreJksPasswordRequired())
  724.                             ||
  725.                             (KeystoreType.PKCS12.isType(keystoreType) && !DBUtils.isTruststorePkcs12PasswordRequired())
  726.                     ) {
  727.                         requiredPassword = false;
  728.                     }
  729.                     if(requiredPassword) {
  730.                         throw new SecurityException(requiredPropertyPrefix+password+"' not found");
  731.                     }
  732.                 }
  733.                 String keystorePassword = (String) properties.get(password);
  734.                 if(keystorePassword==null && requiredPassword) {
  735.                     throw new SecurityException(requiredPropertyPrefix+password+"' is empty");
  736.                 }
  737.                 else if(keystorePassword!=null) {
  738.                     keystorePassword = keystorePassword.trim();
  739.                 }
  740.                 
  741.                 keystore = GestoreKeystoreCache.getMerlinTruststore(requestInfo, keystoreFile, keystoreType, keystorePassword).getTrustStore();
  742.             }
  743.         }
  744.         
  745.         return keystore;
  746.     }
  747.     
  748.     public static final String HTTP_PROTOCOL = "http";
  749.     public static final String HTTPS_PROTOCOL = "https";
  750.     
  751.     public static void injectKeystore(RequestInfo requestInfo, Map<String, Object> dynamicMap, Properties properties, Logger log) {
  752.         try {
  753.             injectKeystore(requestInfo, dynamicMap, properties, log, false);
  754.         }catch(SecurityException e) {
  755.             // ignore per default
  756.         }
  757.     }
  758.     public static void injectKeystore(RequestInfo requestInfo, Map<String, Object> dynamicMap, Properties properties, Logger log, boolean throwError) throws SecurityException {
  759.         
  760.         if(log==null) {
  761.             log = LoggerWrapperFactory.getLogger(JOSEUtils.class);
  762.         }
  763.         
  764.         if(properties!=null && properties.containsKey(SecurityConstants.JOSE_KEYSTORE_FILE)) {
  765.             
  766.             String file = properties.getProperty(SecurityConstants.JOSE_KEYSTORE_FILE);
  767.             String type = properties.getProperty(SecurityConstants.JOSE_KEYSTORE_TYPE);
  768.             if(type==null) {
  769.                 type = SecurityConstants.KEYSTORE_TYPE_JKS_VALUE;
  770.             }
  771.             String password = properties.getProperty(SecurityConstants.JOSE_KEYSTORE_PSWD);
  772.             boolean passwordDefined = (password!=null && !"".equals(password));
  773.             
  774.             String byokPropertyName =  SecurityConstants.JOSE_KEYSTORE_BYOK_POLICY;
  775.             String byokProperty = properties.getProperty(byokPropertyName);
  776.             BYOKRequestParams byokParams = null;
  777.             BYOKUnwrapManager byokManager = null;
  778.             if(BYOKProvider.isPolicyDefined(byokProperty)){
  779.                 try {
  780.                     byokParams = BYOKProvider.getBYOKRequestParamsByUnwrapBYOKPolicy(byokProperty, 
  781.                             dynamicMap!=null ? dynamicMap : new HashMap<>() );
  782.                     byokManager = new BYOKUnwrapManager(byokProperty, byokParams);
  783.                 }catch(Exception e) {
  784.                     String error = "Errore durante istanziazione del byok unwrap manager '"+byokProperty+"': "+e.getMessage();
  785.                     log.error(error,e);
  786.                     if(throwError) {
  787.                         throw new SecurityException(error, e);
  788.                     }
  789.                 }
  790.             }
  791.             
  792.             if(file!=null && !"".equals(file) ) {
  793.                 
  794.                 if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(type)) {
  795.                     
  796.                     String privateKeyPassword = properties.getProperty(RSSecurityConstants.RSSEC_KEY_PSWD);
  797.                     
  798.                     String algorithmPropertyName =  SecurityConstants.JOSE_KEYSTORE_KEY_ALGORITHM;
  799.                     String algorithmProperty = properties.getProperty(algorithmPropertyName);
  800.                     
  801.                     String publicKeyPropertyName =  SecurityConstants.JOSE_KEYSTORE_PUBLIC_KEY;
  802.                     String publicKeyProperty = properties.getProperty(publicKeyPropertyName);
  803.                     if(publicKeyProperty==null || "".equals(publicKeyProperty) ) {
  804.                         String error = "Errore durante l'accesso al keyPair '"+file+"': property public key file ("+publicKeyPropertyName+") undefined";
  805.                         log.error(error);
  806.                         if(throwError) {
  807.                             throw new SecurityException(error);
  808.                         }
  809.                     }
  810.                     else {
  811.                         KeyPairStore keyPair = null;
  812.                         if(file.startsWith(HTTP_PROTOCOL) || file.startsWith(HTTPS_PROTOCOL)) {
  813.                             byte[] privateKey = readHttpStore(properties, requestInfo, file, log, throwError);
  814.                         
  815.                             byte[] publicKey = null;
  816.                             if(publicKeyProperty.startsWith(HTTP_PROTOCOL) || publicKeyProperty.startsWith(HTTPS_PROTOCOL)) {
  817.                                 publicKey = readHttpStore(properties, requestInfo, publicKeyProperty, log, throwError);
  818.                             }
  819.                             else {
  820.                                 String error = "Errore durante l'accesso al keyPair '"+file+"': property public key file ("+publicKeyPropertyName+") expected as http resource: '"+publicKeyProperty+"'";
  821.                                 log.error(error);
  822.                                 if(throwError) {
  823.                                     throw new SecurityException(error);
  824.                                 }
  825.                             }
  826.                             
  827.                             try {
  828.                                 keyPair = new KeyPairStore(privateKey, publicKey, privateKeyPassword, algorithmProperty, byokParams);
  829.                             }catch(Exception e) {
  830.                                 String error = "Errore durante istanziazione del keyPair (http resource) '"+file+"'/'"+publicKeyProperty+"': "+e.getMessage();
  831.                                 log.error(error,e);
  832.                                 if(throwError) {
  833.                                     throw new SecurityException(error, e);
  834.                                 }
  835.                             }
  836.                         }
  837.                         else {
  838.                             try {
  839.                                 keyPair = GestoreKeystoreCache.getKeyPairStore(requestInfo, file, publicKeyProperty, privateKeyPassword, algorithmProperty, byokParams);
  840.                             }catch(Exception e) {
  841.                                 String error = "Errore durante istanziazione del keyPair '"+file+"'/'"+publicKeyProperty+"': "+e.getMessage();
  842.                                 log.error(error,e);
  843.                                 if(throwError) {
  844.                                     throw new SecurityException(error, e);
  845.                                 }
  846.                             }
  847.                         }
  848.                         if(keyPair!=null) {
  849.                             try {
  850.                                 String jwkSet = keyPair.getJwkSet().getJson();
  851.                                 String jwkSetKid = keyPair.getJwkSetKid();
  852.                                 
  853.                                 properties.remove(SecurityConstants.JOSE_KEYSTORE_FILE);
  854.                                 properties.remove(SecurityConstants.JOSE_KEYSTORE_PSWD);
  855.                                 properties.remove(algorithmPropertyName);
  856.                                 properties.remove(publicKeyPropertyName);
  857.                                 properties.remove(RSSecurityConstants.RSSEC_KEY_PSWD);
  858.                                 properties.remove(SecurityConstants.JOSE_KEYSTORE_KEY_ALIAS);
  859.                                 properties.remove(SecurityConstants.JOSE_KEYSTORE_TYPE);
  860.                                 properties.put(SecurityConstants.JOSE_KEYSTORE_JWKSET, jwkSet);
  861.                                 properties.put(SecurityConstants.JOSE_KEYSTORE_KEY_ALIAS, jwkSetKid);
  862.                                 properties.put(SecurityConstants.JOSE_KEYSTORE_TYPE, SecurityConstants.KEYSTORE_TYPE_JWK_VALUE);
  863.                             }catch(Exception e) {
  864.                                 String error = "Errore durante istanziazione del keyPair '"+file+"'/'"+publicKeyProperty+"': "+e.getMessage();
  865.                                 log.error(error,e);
  866.                                 if(throwError) {
  867.                                     throw new SecurityException(error, e);
  868.                                 }
  869.                             }
  870.                         }
  871.                     }
  872.                     
  873.                 }
  874.                 
  875.                 else if(SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(type)) {
  876.                     
  877.                     String algorithmPropertyName =  SecurityConstants.JOSE_KEYSTORE_KEY_ALGORITHM;
  878.                     String algorithmProperty = properties.getProperty(algorithmPropertyName);
  879.                     
  880.                     PublicKeyStore publicKeyStore = null;
  881.                     if(file.startsWith(HTTP_PROTOCOL) || file.startsWith(HTTPS_PROTOCOL)) {
  882.                         byte[] publicKey = readHttpStore(properties, requestInfo, file, log, throwError);
  883.                                             
  884.                         try {
  885.                             publicKeyStore = new PublicKeyStore(publicKey, algorithmProperty);
  886.                         }catch(Exception e) {
  887.                             String error = "Errore durante istanziazione della chiave pubblica (http resource) '"+file+"': "+e.getMessage();
  888.                             log.error(error,e);
  889.                             if(throwError) {
  890.                                 throw new SecurityException(error, e);
  891.                             }
  892.                         }
  893.                     }
  894.                     else {
  895.                         try {
  896.                             publicKeyStore = GestoreKeystoreCache.getPublicKeyStore(requestInfo, file, algorithmProperty);
  897.                         }catch(Exception e) {
  898.                             String error = "Errore durante istanziazione della chiave pubblica '"+file+"': "+e.getMessage();
  899.                             log.error(error,e);
  900.                             if(throwError) {
  901.                                 throw new SecurityException(error, e);
  902.                             }
  903.                         }
  904.                     }
  905.                     if(publicKeyStore!=null) {
  906.                         try {
  907.                             String jwkSet = publicKeyStore.getJwkSet().getJson();
  908.                             String jwkSetKid = publicKeyStore.getJwkSetKid();
  909.                             
  910.                             properties.remove(SecurityConstants.JOSE_KEYSTORE_FILE);
  911.                             properties.remove(SecurityConstants.JOSE_KEYSTORE_PSWD);
  912.                             properties.remove(algorithmPropertyName);
  913.                             properties.remove(RSSecurityConstants.RSSEC_KEY_PSWD);
  914.                             properties.remove(SecurityConstants.JOSE_KEYSTORE_KEY_ALIAS);
  915.                             properties.remove(SecurityConstants.JOSE_KEYSTORE_TYPE);
  916.                             properties.put(SecurityConstants.JOSE_KEYSTORE_JWKSET, jwkSet);
  917.                             properties.put(SecurityConstants.JOSE_KEYSTORE_KEY_ALIAS, jwkSetKid);
  918.                             properties.put(SecurityConstants.JOSE_KEYSTORE_TYPE, SecurityConstants.KEYSTORE_TYPE_JWK_VALUE);
  919.                         }catch(Exception e) {
  920.                             String error = "Errore durante istanziazione della chiave pubblica '"+file+"': "+e.getMessage();
  921.                             log.error(error,e);
  922.                             if(throwError) {
  923.                                 throw new SecurityException(error, e);
  924.                             }
  925.                         }
  926.                     }
  927.                     
  928.                 }
  929.                 
  930.                 else if( passwordDefined
  931.                         || 
  932.                         ((!DBUtils.isKeystoreJksPasswordRequired()) && SecurityConstants.KEYSTORE_TYPE_JKS_VALUE.equalsIgnoreCase(type))
  933.                         || 
  934.                         ((!DBUtils.isKeystorePkcs12PasswordRequired()) && SecurityConstants.KEYSTORE_TYPE_PKCS12_VALUE.equalsIgnoreCase(type))
  935.                         || 
  936.                         SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(type)) {
  937.                     
  938.                     if(file.startsWith(HTTP_PROTOCOL) || file.startsWith(HTTPS_PROTOCOL)) {
  939.                         
  940.                         byte[]content = readHttpStore(properties, requestInfo, file, log, throwError);
  941.                         
  942.                         if(byokManager!=null) {
  943.                             try {
  944.                                 content = byokManager.unwrap(content);
  945.                             }catch(Exception e) {
  946.                                 String error = "Errore durante l'unwrap del keystore ottenuto via http '"+file+"': "+e.getMessage();
  947.                                 log.error(error,e);
  948.                                 if(throwError) {
  949.                                     throw new SecurityException(error, e);
  950.                                 }
  951.                             }
  952.                         }
  953.                         
  954.                         if(content!=null) {
  955.                             if(SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(type)) {
  956.                                 properties.remove(SecurityConstants.JOSE_KEYSTORE_FILE);
  957.                                 properties.remove(SecurityConstants.JOSE_KEYSTORE_PSWD);
  958.                                 properties.put(SecurityConstants.JOSE_KEYSTORE_JWKSET, new String(content));
  959.                             }
  960.                             else {
  961.                                 java.security.KeyStore keystore = null;
  962.                                 try {
  963.                                     keystore = KeystoreUtils.readKeystore(content, type, password);
  964.                                 }catch(Exception e) {
  965.                                     String error = "Errore durante istanziazione del keystore ottenuto via http '"+file+"': "+e.getMessage();
  966.                                     log.error(error,e);
  967.                                     keystore = null;
  968.                                     if(throwError) {
  969.                                         throw new SecurityException(error, e);
  970.                                     }
  971.                                 }
  972.                                 if(keystore!=null) {
  973.                                     properties.remove(SecurityConstants.JOSE_KEYSTORE_FILE);
  974.                                     // properties.remove(SecurityConstants.JOSE_KEYSTORE_TYPE); non va rimosso, serve per jceks
  975.                                     properties.remove(SecurityConstants.JOSE_KEYSTORE_PSWD);
  976.                                     properties.put(SecurityConstants.JOSE_KEYSTORE, keystore);
  977.                                 }
  978.                             }
  979.                         }
  980.                     }
  981.                     else {
  982.                         if(SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(type)) {
  983.                             String jwkSet = null;
  984.                             try {
  985.                                 jwkSet = GestoreKeystoreCache.getJwkSetStore(requestInfo, file, byokParams).getJwkSetContent();
  986.                             }catch(Exception e) {
  987.                                 String error = "Errore durante l'accesso al jwk set '"+file+"': "+e.getMessage();
  988.                                 log.error(error,e);
  989.                                 if(throwError) {
  990.                                     throw new SecurityException(error, e);
  991.                                 }
  992.                             }
  993.                             if(jwkSet!=null) {
  994.                                 properties.remove(SecurityConstants.JOSE_KEYSTORE_FILE);
  995.                                 properties.remove(SecurityConstants.JOSE_KEYSTORE_PSWD);
  996.                                 properties.put(SecurityConstants.JOSE_KEYSTORE_JWKSET, jwkSet);
  997.                             }
  998.                         }
  999.                         else {
  1000.                             java.security.KeyStore keystore = null;
  1001.                             try {
  1002.                                 MerlinKeystore merlinKeystore = GestoreKeystoreCache.getMerlinKeystore(requestInfo, file, type, password, byokParams);
  1003.                                 if(merlinKeystore==null) {
  1004.                                     throw new SecurityException("Keystore '"+file+"' undefined");
  1005.                                 }
  1006.                                 KeyStore keystoreUtils = merlinKeystore.getKeyStore();
  1007.                                 if(keystoreUtils==null) {
  1008.                                     throw new SecurityException("Keystore '"+file+"' undefined");
  1009.                                 }
  1010.                                 keystore = keystoreUtils.getKeystore();
  1011.                             }catch(Exception e) {
  1012.                                 String error = "Errore durante l'accesso al keystore '"+file+"': "+e.getMessage();
  1013.                                 log.error(error,e);
  1014.                                 if(throwError) {
  1015.                                     throw new SecurityException(error, e);
  1016.                                 }
  1017.                             }
  1018.                             if(keystore!=null) {
  1019.                                 properties.remove(SecurityConstants.JOSE_KEYSTORE_FILE);
  1020.                                 // properties.remove(SecurityConstants.JOSE_KEYSTORE_TYPE); non va rimosso, serve per jceks
  1021.                                 properties.remove(SecurityConstants.JOSE_KEYSTORE_PSWD);
  1022.                                 properties.put(SecurityConstants.JOSE_KEYSTORE, keystore);
  1023.                             }
  1024.                         }
  1025.                     }
  1026.                 }
  1027.             }
  1028.         }
  1029.         
  1030.     }
  1031.     
  1032.     public static byte[] readHttpStore(Properties properties, RequestInfo requestInfo, String file, Logger log, boolean throwError) throws SecurityException {
  1033.         return readHttpStore( properties, requestInfo, file, log, throwError, false);
  1034.     }
  1035.     public static byte[] readHttpStore(Properties properties, RequestInfo requestInfo, String file, Logger log, boolean throwError, boolean forceNoCache) throws SecurityException {
  1036.         byte[]content = null;
  1037.         try {
  1038.             boolean trustAll = false;
  1039.             String trustStoreAllSslProperty = properties.getProperty(JOSECostanti.ID_TRUSTSTORE_SSL_KEYSTORE_TRUSTALL);
  1040.             trustAll = trustStoreAllSslProperty!=null && "true".equalsIgnoreCase(trustStoreAllSslProperty);
  1041.             
  1042.             String trustStoreSslPropertyName = JOSECostanti.ID_TRUSTSTORE_SSL_KEYSTORE_FILE;
  1043.             String trustStoreSslProperty =  properties.getProperty(trustStoreSslPropertyName);
  1044.             MerlinTruststore trustStoreSsl = null;
  1045.             if(trustStoreSslProperty!=null) {
  1046.                 String trustStoreSslPasswordPropertyName = JOSECostanti.ID_TRUSTSTORE_SSL_KEYSTORE_PASSWORD;
  1047.                 String trustStoreSslTypePropertyName = JOSECostanti.ID_TRUSTSTORE_SSL_KEYSTORE_TYPE;
  1048.                 String trustStoreSslPasswordProperty = properties.getProperty(trustStoreSslPasswordPropertyName);
  1049.                 String trustStoreSslTypeProperty = properties.getProperty(trustStoreSslTypePropertyName);
  1050.                 if(trustStoreSslTypeProperty==null) {
  1051.                     throw new SecurityException("TrustStore ssl type undefined");
  1052.                 }
  1053.                 if(trustStoreSslPasswordProperty==null) {
  1054.                     boolean required = true;
  1055.                     if(KeystoreType.JKS.isType(trustStoreSslTypeProperty)) {
  1056.                         required = DBUtils.isTruststoreJksPasswordRequired();
  1057.                     }
  1058.                     else if(KeystoreType.PKCS12.isType(trustStoreSslTypeProperty)) {
  1059.                         required = DBUtils.isTruststorePkcs12PasswordRequired();
  1060.                     }
  1061.                     if(required) {
  1062.                         throw new SecurityException("TrustStore ssl password undefined");
  1063.                     }
  1064.                 }
  1065.                 trustStoreSsl = GestoreKeystoreCache.getMerlinTruststore(requestInfo, trustStoreSslProperty, trustStoreSslTypeProperty, trustStoreSslPasswordProperty);
  1066.             }
  1067.             
  1068.             String trustStoreSslCrlPropertyName =  JOSECostanti.ID_TRUSTSTORE_SSL_KEYSTORE_CRL;
  1069.             String trustStoreSslCrlProperty =  properties.getProperty(trustStoreSslCrlPropertyName);
  1070.             CRLCertstore crlStore = null;
  1071.             if(trustStoreSslCrlProperty!=null) {
  1072.                 crlStore = GestoreKeystoreCache.getCRLCertstore(requestInfo, trustStoreSslCrlProperty);
  1073.             }
  1074.             
  1075.             String trustStoreSslConnectionTimeoutPropertyName =  JOSECostanti.ID_TRUSTSTORE_SSL_KEYSTORE_CONNECTION_TIMEOUT;
  1076.             String trustStoreSslReadTimeoutPropertyName =  JOSECostanti.ID_TRUSTSTORE_SSL_KEYSTORE_READ_TIMEOUT;
  1077.             String trustStoreSslConnectionTimeoutProperty =  properties.getProperty(trustStoreSslConnectionTimeoutPropertyName);
  1078.             String trustStoreSslReadTimeoutProperty =  properties.getProperty(trustStoreSslReadTimeoutPropertyName);
  1079.             Integer connectionTimeout = null;
  1080.             Integer readTimeout = null;
  1081.             if(trustStoreSslConnectionTimeoutProperty!=null && trustStoreSslReadTimeoutProperty!=null) {
  1082.                 connectionTimeout = Integer.valueOf(trustStoreSslConnectionTimeoutProperty);
  1083.                 readTimeout = Integer.valueOf(trustStoreSslReadTimeoutProperty);
  1084.             }
  1085.             
  1086.             List<HttpOptions> list = new ArrayList<>();
  1087.             
  1088.             String trustStoreSslHostnameVerifier =  properties.getProperty(JOSECostanti.ID_TRUSTSTORE_SSL_KEYSTORE_HOSTNAME_VERIFIER);
  1089.             if(trustStoreSslHostnameVerifier!=null && StringUtils.isNotEmpty(trustStoreSslHostnameVerifier)) {
  1090.                 HttpsOptions op = new HttpsOptions();
  1091.                 op.setHostnameVerifier("true".equals(trustStoreSslHostnameVerifier)); // lascio default a false
  1092.                 list.add(op);
  1093.             }
  1094.             
  1095.             String forwardProxyEndpoint = properties.getProperty(JOSECostanti.ID_FORWARD_PROXY_ENDPOINT);
  1096.             if(forwardProxyEndpoint!=null && StringUtils.isNotEmpty(forwardProxyEndpoint)) {
  1097.                 HttpForwardProxyOptions op = new HttpForwardProxyOptions();
  1098.                 op.setForwardProxyEndpoint(forwardProxyEndpoint);
  1099.                 
  1100.                 HttpForwardProxyConfig c = new HttpForwardProxyConfig();
  1101.                 String forwardProxyHeader = properties.getProperty(JOSECostanti.ID_FORWARD_PROXY_HEADER);
  1102.                 String forwardProxyQuery = properties.getProperty(JOSECostanti.ID_FORWARD_PROXY_QUERY);
  1103.                 if(forwardProxyHeader!=null && StringUtils.isNotEmpty(forwardProxyHeader)) {
  1104.                     c.setHeader(forwardProxyHeader);
  1105.                     String forwardProxyHeaderBase64 = properties.getProperty(JOSECostanti.ID_FORWARD_PROXY_HEADER_BASE64);
  1106.                     if(forwardProxyHeaderBase64!=null && StringUtils.isNotEmpty(forwardProxyHeaderBase64)) {
  1107.                         c.setHeaderBase64("false".equals(forwardProxyHeaderBase64)); // default true
  1108.                     }
  1109.                 }
  1110.                 else if(forwardProxyQuery!=null && StringUtils.isNotEmpty(forwardProxyQuery)) {
  1111.                     c.setQuery(forwardProxyQuery);
  1112.                     String forwardProxyQueryBase64 = properties.getProperty(JOSECostanti.ID_FORWARD_PROXY_QUERY_BASE64);
  1113.                     if(forwardProxyQueryBase64!=null && StringUtils.isNotEmpty(forwardProxyQueryBase64)) {
  1114.                         c.setQueryBase64("false".equals(forwardProxyQueryBase64)); // default true
  1115.                     }
  1116.                 }
  1117.                 else {
  1118.                     throw new SecurityException("ForwardProxy header o query required");
  1119.                 }
  1120.                 op.setForwardProxyConfig(c);
  1121.                 
  1122.                 list.add(op);
  1123.             }
  1124.             
  1125.             String proxyType = properties.getProperty(JOSECostanti.ID_PROXY_TYPE);
  1126.             if(proxyType!=null && StringUtils.isNotEmpty(proxyType)) {
  1127.                 HttpProxyOptions op = new HttpProxyOptions();
  1128.                 if(CostantiConnettori.CONNETTORE_HTTP_PROXY_TYPE_VALUE_HTTP.equals(proxyType)){
  1129.                     op.setProxyType(Proxy.Type.HTTP);
  1130.                 }
  1131.                 else if(CostantiConnettori.CONNETTORE_HTTP_PROXY_TYPE_VALUE_HTTPS.equals(proxyType)){
  1132.                     op.setProxyType(Proxy.Type.HTTP); // voluto
  1133.                 }
  1134.                 else{
  1135.                     throw new SecurityException("Proxy type '"+proxyType+"' unsupported");
  1136.                 }
  1137.                 
  1138.                 String proxyHostname = properties.getProperty(JOSECostanti.ID_PROXY_HOSTNAME);
  1139.                 if(proxyHostname!=null && StringUtils.isNotEmpty(proxyHostname)) {
  1140.                     op.setProxyHostname(proxyHostname);
  1141.                 }
  1142.                 else{
  1143.                     throw new SecurityException("Proxy hostname undefined");
  1144.                 }
  1145.                 
  1146.                 String proxyPort = properties.getProperty(JOSECostanti.ID_PROXY_HOSTNAME);
  1147.                 if(proxyPort!=null && StringUtils.isNotEmpty(proxyPort)) {
  1148.                     try {
  1149.                         op.setProxyPort(Integer.valueOf(proxyPort));
  1150.                     }catch(Exception e) {
  1151.                         throw new SecurityException("Proxy port '"+proxyPort+"' invalid: "+e.getMessage());
  1152.                     }
  1153.                 }
  1154.                 else{
  1155.                     throw new SecurityException("Proxy port undefined");
  1156.                 }
  1157.                 
  1158.                 String proxyUsername = properties.getProperty(JOSECostanti.ID_PROXY_USERNAME);
  1159.                 if(proxyUsername!=null && StringUtils.isNotEmpty(proxyUsername)) {
  1160.                     op.setProxyUsername(proxyUsername);
  1161.                     String proxyPassword = properties.getProperty(JOSECostanti.ID_PROXY_USERNAME);
  1162.                     if(proxyPassword!=null) {
  1163.                         op.setProxyPassword(proxyPassword);
  1164.                     }
  1165.                 }
  1166.                 
  1167.                 list.add(op);
  1168.             }
  1169.             
  1170.             HttpOptions [] options = null;
  1171.             if(!list.isEmpty()) {
  1172.                 options = list.toArray(new HttpOptions[1]);
  1173.             }
  1174.             if(forceNoCache) {
  1175.                 if(connectionTimeout!=null && readTimeout!=null) {
  1176.                     if(trustStoreSsl!=null) {
  1177.                         if(crlStore!=null) {
  1178.                             content = new HttpStore(file, connectionTimeout, readTimeout, trustStoreSsl, crlStore, options).getStoreBytes();
  1179.                         }
  1180.                         else {
  1181.                             content = new HttpStore(file, connectionTimeout, readTimeout, trustStoreSsl, options).getStoreBytes();
  1182.                         }
  1183.                     }
  1184.                     else if(trustAll) {
  1185.                         content = new HttpStore(file, connectionTimeout, readTimeout, trustAll, options).getStoreBytes();
  1186.                     }
  1187.                     else {
  1188.                         content = new HttpStore(file, connectionTimeout, readTimeout, options).getStoreBytes();
  1189.                     }
  1190.                 }
  1191.                 else {
  1192.                     if(trustStoreSsl!=null) {
  1193.                         if(crlStore!=null) {
  1194.                             content = new HttpStore(file, trustStoreSsl, crlStore, options).getStoreBytes();
  1195.                         }
  1196.                         else {
  1197.                             content = new HttpStore(file, trustStoreSsl, options).getStoreBytes();
  1198.                         }
  1199.                     }
  1200.                     else if(trustAll) {
  1201.                         content = new HttpStore(file, trustAll, options).getStoreBytes();
  1202.                     }
  1203.                     else {
  1204.                         content = new HttpStore(file, options).getStoreBytes();
  1205.                     }
  1206.                 }
  1207.             }
  1208.             else {
  1209.                 if(connectionTimeout!=null && readTimeout!=null) {
  1210.                     if(trustStoreSsl!=null) {
  1211.                         if(crlStore!=null) {
  1212.                             content = GestoreKeystoreCache.getHttpStore(requestInfo, file, connectionTimeout, readTimeout, trustStoreSsl, crlStore, options).getStoreBytes();
  1213.                         }
  1214.                         else {
  1215.                             content = GestoreKeystoreCache.getHttpStore(requestInfo, file, connectionTimeout, readTimeout, trustStoreSsl, options).getStoreBytes();
  1216.                         }
  1217.                     }
  1218.                     else if(trustAll) {
  1219.                         content = GestoreKeystoreCache.getHttpStore(requestInfo, file, connectionTimeout, readTimeout, trustAll, options).getStoreBytes();
  1220.                     }
  1221.                     else {
  1222.                         content = GestoreKeystoreCache.getHttpStore(requestInfo, file, connectionTimeout, readTimeout, options).getStoreBytes();
  1223.                     }
  1224.                 }
  1225.                 else {
  1226.                     if(trustStoreSsl!=null) {
  1227.                         if(crlStore!=null) {
  1228.                             content = GestoreKeystoreCache.getHttpStore(requestInfo, file, trustStoreSsl, crlStore, options).getStoreBytes();
  1229.                         }
  1230.                         else {
  1231.                             content = GestoreKeystoreCache.getHttpStore(requestInfo, file, trustStoreSsl, options).getStoreBytes();
  1232.                         }
  1233.                     }
  1234.                     else if(trustAll) {
  1235.                         content = GestoreKeystoreCache.getHttpStore(requestInfo, file, trustAll, options).getStoreBytes();
  1236.                     }
  1237.                     else {
  1238.                         content = GestoreKeystoreCache.getHttpStore(requestInfo, file, options).getStoreBytes();
  1239.                     }
  1240.                 }
  1241.             }
  1242.         }catch(Exception e) {
  1243.             String error = "Errore durante l'accesso al keystore via http '"+file+"': "+e.getMessage();
  1244.             log.error(error,e);
  1245.             if(throwError) {
  1246.                 throw new SecurityException(error, e);
  1247.             }
  1248.         }
  1249.         return content;
  1250.     }
  1251. }
Created with JaCoCo 0.8.8.202204050719