RemoteStoreConfigPropertiesUtils.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.  */
  20. package org.openspcoop2.pdd.core.keystore;

  22. import java.util.ArrayList;
  23. import java.util.HashMap;
  24. import java.util.List;
  25. import java.util.Map;
  26. import java.util.Properties;

  28. import org.apache.commons.lang.StringUtils;
  29. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  30. import org.openspcoop2.utils.certificate.KeystoreType;
  31. import org.openspcoop2.utils.certificate.remote.RemoteKeyIdMode;
  32. import org.openspcoop2.utils.certificate.remote.RemoteStoreConfig;
  33. import org.openspcoop2.utils.properties.PropertiesReader;
  34. import org.openspcoop2.utils.transport.http.HttpUtilities;

  36. /**
  37.  * RemoteStoreConfigPropertiesUtils
  38.  *
  39.  * @author Andrea Poli (apoli@link.it)
  40.  * @author $Author$
  41.  * @version $Rev$, $Date$
  42.  */
  43. public class RemoteStoreConfigPropertiesUtils {
  44.     
  45.     private RemoteStoreConfigPropertiesUtils() {}

  47.     public static final String PROPERTY_STORE_NAME = "name";
  48.     public static final String PROPERTY_STORE_LABEL = "label";
  49.     
  50.     public static final String PROPERTY_STORE_TOKEN_POLICY = "tokenPolicy";
  51.     
  52.     public static final String PROPERTY_STORE_URL = "baseUrl";
  53.     
  54.     public static final String PROPERTY_STORE_ID_MODE = "keyId.mode";
  55.     public static final String PROPERTY_STORE_ID_PARAMETER_NAME = "keyId.parameter";
  56.     
  57.     public static final String PROPERTY_STORE_KEY_ALGORITHM = "keyAlgorithm";
  58.     
  59.     public static final String PROPERTY_READ_TIMEOUT = "readTimeout";
  60.     public static final String PROPERTY_CONNECT_TIMEOUT = "connectTimeout";
  61.     
  62.     public static final String PROPERTY_HTTP_BASIC_USERNAME = "http.username";
  63.     public static final String PROPERTY_HTTP_BASIC_USERNAME_DISABLE_VALUE = "#none#";
  64.     public static final String PROPERTY_HTTP_BASIC_PASSWORD = "http.password";

  66.     public static final String PROPERTY_HTTP_HEADER_PREFIX = "http.header.";
  67.     
  68.     public static final String PROPERTY_HTTP_QUERY_PARAMETER_PREFIX = "http.queryParameter.";
  69.     
  70.     public static final String PROPERTY_HTTPS_HOSTNAME_VERIFIER = "https.hostnameVerifier";
  71.     public static final String PROPERTY_HTTPS_TRUST_ALL_CERTS = "https.trustAllCerts";
  72.     public static final String PROPERTY_HTTPS_TRUST_STORE = "https.trustStore";
  73.     public static final String PROPERTY_HTTPS_TRUST_STORE_PASSWORD = "https.trustStore.password";
  74.     public static final String PROPERTY_HTTPS_TRUST_STORE_TYPE = "https.trustStore.type";
  75.     public static final String PROPERTY_HTTPS_TRUST_STORE_CRL = "https.trustStore.crl";

  77.     public static final String PROPERTY_HTTPS_KEY_STORE = "https.keyStore";
  78.     public static final String PROPERTY_HTTPS_KEY_STORE_PASSWORD = "https.keyStore.password";
  79.     public static final String PROPERTY_HTTPS_KEY_STORE_TYPE = "https.keyStore.type";
  80.     public static final String PROPERTY_HTTPS_KEY_ALIAS = "https.key.alias";
  81.     public static final String PROPERTY_HTTPS_KEY_PASSWORD = "https.key.password";

  83.     public static final String PROPERTY_FORWARD_PROXY_URL = "forwardProxy.url";
  84.     public static final String PROPERTY_FORWARD_PROXY_HEADER = "forwardProxy.header";
  85.     public static final String PROPERTY_FORWARD_PROXY_QUERY_PARAMETER = "forwardProxy.queryParameter";
  86.     public static final String PROPERTY_FORWARD_PROXY_BASE64 = "forwardProxy.base64";
  87.     
  88.     public static final String PROPERTY_MULTITENANT = "multiTenant";
  89.     
  90.     public static final String PROPERTY_MULTITENANT_BASEURL_DEFAULT_STRING = "multiTenant.baseUrl.defaultString";
  91.     public static final String PROPERTY_MULTITENANT_BASEURL_PLACEHOLDER = "multiTenant.baseUrl.placeholder";
  92.     public static final String PROPERTY_MULTITENANT_BASEURL_TENANT_STRING = "multiTenant.baseUrl.tenantString";
  93.     
  94.     public static final String PROPERTY_MULTITENANT_BASE_URL_PREFIX = "multiTenant.baseUrl.";

  96.     public static final String PROPERTY_MULTITENANT_HTTP_BASIC_USERNAME_PREFIX = "multiTenant.http.username.";
  97.     public static final String PROPERTY_MULTITENANT_HTTP_BASIC_PASSWORD_PREFIX = "multiTenant.http.password.";

  99.     public static final String PROPERTY_MULTITENANT_HTTP_HEADER_PREFIX = "multiTenant.http.header.";
  100.     
  101.     public static final String PROPERTY_MULTITENANT_HTTP_QUERY_PARAMETER_PREFIX = "multiTenant.http.queryParameter.";
  102.     
  103.     
  104.     public static RemoteStoreConfig read(Properties p, RequestInfo requestInfo) throws KeystoreException {
  105.         
  106.         String storeName = getProperty(p, PROPERTY_STORE_NAME, true);
  107.         
  108.         RemoteStoreConfig config = new RemoteStoreConfig(storeName);
  109.         
  110.         String storeLabel = getProperty(p, PROPERTY_STORE_LABEL, false);
  111.         if(storeLabel!=null && StringUtils.isNotEmpty(storeLabel)) {
  112.             config.setStoreLabel(storeLabel);
  113.         }
  114.         
  115.         String tokenPolicy = getProperty(p, PROPERTY_STORE_TOKEN_POLICY, false);
  116.         if(tokenPolicy!=null && StringUtils.isNotEmpty(tokenPolicy)) {
  117.             config.setTokenPolicy(tokenPolicy);
  118.         }
  119.         
  120.         String storeUrl = getProperty(p, PROPERTY_STORE_URL, true);
  121.         config.setBaseUrl(storeUrl);
  122.         
  123.         String idMode = getProperty(p, PROPERTY_STORE_ID_MODE, true);
  124.         RemoteKeyIdMode keyIdMode = RemoteKeyIdMode.valueOf(idMode);
  125.         config.setIdMode(keyIdMode);
  126.         
  127.         switch (keyIdMode) {
  128.         case HEADER:
  129.         case URL_PARAMETER:
  130.             config.setParameterName(getProperty(p, PROPERTY_STORE_ID_PARAMETER_NAME, true));
  131.             break;
  132.         default:
  133.             break;
  134.         }
  135.         
  136.         String keyAlgo = getProperty(p, PROPERTY_STORE_KEY_ALGORITHM, false);
  137.         if(keyAlgo!=null && StringUtils.isNotEmpty(keyAlgo)) {
  138.             config.setKeyAlgorithm(keyAlgo);
  139.         }

  141.         config.setReadTimeout(getIntProperty(p, PROPERTY_READ_TIMEOUT, false, 15000));
  142.         config.setConnectTimeout(getIntProperty(p, PROPERTY_CONNECT_TIMEOUT, false, HttpUtilities.HTTP_CONNECTION_TIMEOUT));
  143.         
  144.         String basicUsername = getProperty(p, PROPERTY_HTTP_BASIC_USERNAME, false);
  145.         if(basicUsername!=null && StringUtils.isNotEmpty(basicUsername) && !PROPERTY_HTTP_BASIC_USERNAME_DISABLE_VALUE.equals(basicUsername)) {
  146.             config.setBasicUsername(basicUsername);
  147.             
  148.             String basicPassword = getProperty(p, PROPERTY_HTTP_BASIC_PASSWORD, false);
  149.             if(basicPassword!=null && StringUtils.isNotEmpty(basicPassword)) {
  150.                 config.setBasicPassword(basicPassword);
  151.             }
  152.         }
  153.         
  154.         PropertiesReader pReader = new PropertiesReader(p, false);
  155.         
  156.         config.setHeaders(read(pReader, PROPERTY_HTTP_HEADER_PREFIX, config.getHeaders()));
  157.         
  158.         config.setQueryParameters(read(pReader, PROPERTY_HTTP_QUERY_PARAMETER_PREFIX, config.getQueryParameters()));
  159.             
  160.         config.setHostnameVerifier(getBooleanProperty(p, PROPERTY_HTTPS_HOSTNAME_VERIFIER, false, true));   
  161.         
  162.         readTrustStoreConfig(config, p, requestInfo);
  163.         
  164.         readKeyStoreConfig(config, p, requestInfo);
  165.         
  166.         readForwardProxyConfig(config, p);
  167.         
  168.         List<String> multi = readMultitenant(p);
  169.         if(multi!=null && !multi.isEmpty()) {
  170.             setMultitenant(config, multi, p, pReader);
  171.         }
  172.         
  173.         return config;
  174.     }
  175.     
  176.     private static Map<String, String> read(PropertiesReader pReader, String pName, Map<String, String> map) throws KeystoreException {
  177.         Properties properties = null;
  178.         try {
  179.             properties = pReader.readProperties_convertEnvProperties(pName);
  180.         }catch(Exception e) {
  181.             throw new KeystoreException("Property '"+pName+".*' read failed: "+e.getMessage(),e);
  182.         }
  183.         if(properties!=null && !properties.isEmpty()) {
  184.             for (Map.Entry<Object,Object> entry : properties.entrySet()) {
  185.                 if(entry.getKey() instanceof String && entry.getValue() instanceof String) {
  186.                     String name = (String) entry.getKey();
  187.                     String value = (String) entry.getValue();
  188.                     if(map==null) {
  189.                         map = new HashMap<>();
  190.                     }
  191.                     map.put(name, value);
  192.                 }
  193.             }
  194.         }
  195.         return map;
  196.     }
  197.     
  198.     private static List<String> readMultitenant(Properties p) throws KeystoreException{
  199.         List<String> l = new ArrayList<>();
  200.         String multi = getProperty(p, PROPERTY_MULTITENANT, false);
  201.         if(multi==null || StringUtils.isEmpty(multi.trim())) {
  202.             return l;
  203.         }
  204.         multi = multi.trim();
  205.         if(!multi.contains(",")) {
  206.             l.add(multi);
  207.             return l;
  208.         }
  209.         String [] tmp = multi.split(",");
  210.         if(tmp!=null && tmp.length>0) {
  211.             for (String s : tmp) {
  212.                 if(s!=null && StringUtils.isNotEmpty(s.trim())) {
  213.                     l.add(s.trim());
  214.                 }
  215.             }
  216.         }
  217.         return l;
  218.     }
  219.     
  220.     private static void setMultitenant(RemoteStoreConfig config, List<String> multi, Properties p, PropertiesReader pReader) throws KeystoreException {
  221.         config.setMultitenant(true);
  222.         
  223.         String defaultS = getProperty(p, PROPERTY_MULTITENANT_BASEURL_DEFAULT_STRING, false);
  224.         boolean requiredMultitenantBaseUrlConfig = StringUtils.isNotEmpty(defaultS);
  225.         config.setBaseUrlMultitenantDefaultString(defaultS);
  226.         config.setBaseUrlMultitenantPlaceholder(getProperty(p, PROPERTY_MULTITENANT_BASEURL_PLACEHOLDER, requiredMultitenantBaseUrlConfig));
  227.         config.setBaseUrlMultitenantTenantString(getProperty(p, PROPERTY_MULTITENANT_BASEURL_TENANT_STRING, requiredMultitenantBaseUrlConfig));
  228.         
  229.         for (String tenant : multi) {
  230.             setMultitenantBaseUrl(config, tenant, p);
  231.             setMultitenantHttpBasic(config, tenant, p);
  232.             setMultitenantHttp(config, tenant, pReader);
  233.         }
  234.     }
  235.     private static void setMultitenantBaseUrl(RemoteStoreConfig config, String tenant, Properties p) throws KeystoreException {
  236.         String baseUrl = getProperty(p, PROPERTY_MULTITENANT_BASE_URL_PREFIX+tenant, false);
  237.         if(baseUrl!=null) {
  238.             if(config.getMultiTenantBaseUrl()==null) {
  239.                 config.setMultiTenantBaseUrl(new HashMap<>());
  240.             }
  241.             config.getMultiTenantBaseUrl().put(tenant, baseUrl);
  242.         }
  243.     }
  244.     private static void setMultitenantHttpBasic(RemoteStoreConfig config, String tenant, Properties p) throws KeystoreException {
  245.         String username = getProperty(p, PROPERTY_MULTITENANT_HTTP_BASIC_USERNAME_PREFIX+tenant, false);
  246.         if(username!=null) {
  247.             if(config.getMultiTenantBasicUsername()==null) {
  248.                 config.setMultiTenantBasicUsername(new HashMap<>());
  249.             }
  250.             config.getMultiTenantBasicUsername().put(tenant, username);
  251.         }
  252.         
  253.         String password = getProperty(p, PROPERTY_MULTITENANT_HTTP_BASIC_PASSWORD_PREFIX+tenant, false);
  254.         if(password!=null) {
  255.             if(config.getMultiTenantBasicPassword()==null) {
  256.                 config.setMultiTenantBasicPassword(new HashMap<>());
  257.             }
  258.             config.getMultiTenantBasicPassword().put(tenant, password);
  259.         }
  260.     }
  261.     private static void setMultitenantHttp(RemoteStoreConfig config, String tenant, PropertiesReader pReader) throws KeystoreException {
  262.         Map<String, String> header = read(pReader, PROPERTY_MULTITENANT_HTTP_HEADER_PREFIX+tenant+".", config.getMultiTenantHeaders()!=null ? config.getMultiTenantHeaders().get(tenant) : null);
  263.         if(header!=null && !header.isEmpty()) {
  264.             if(config.getMultiTenantHeaders()==null) {
  265.                 config.setMultiTenantHeaders(new HashMap<>());
  266.             }
  267.             config.getMultiTenantHeaders().put(tenant, header);
  268.         }
  269.         
  270.         Map<String, String> query = read(pReader, PROPERTY_MULTITENANT_HTTP_QUERY_PARAMETER_PREFIX+tenant+".", config.getMultiTenantQueryParameters()!=null ? config.getMultiTenantQueryParameters().get(tenant) : null);
  271.         if(query!=null && !query.isEmpty()) {
  272.             if(config.getMultiTenantQueryParameters()==null) {
  273.                 config.setMultiTenantQueryParameters(new HashMap<>());
  274.             }
  275.             config.getMultiTenantQueryParameters().put(tenant, query);
  276.         }
  277.     }
  278.     
  279.     private static void readTrustStoreConfig(RemoteStoreConfig config, Properties p, RequestInfo requestInfo) throws KeystoreException {
  280.         config.setTrustAllCerts(getBooleanProperty(p, PROPERTY_HTTPS_TRUST_ALL_CERTS, false, false));   
  281.         String trustStorePath = getProperty(p, PROPERTY_HTTPS_TRUST_STORE, false);  
  282.         if(trustStorePath!=null && StringUtils.isNotEmpty(trustStorePath)) {
  283.             String trustStorePassword = getProperty(p, PROPERTY_HTTPS_TRUST_STORE_PASSWORD, true);  
  284.             String trustStoreType = getProperty(p, PROPERTY_HTTPS_TRUST_STORE_TYPE, false);
  285.             if(trustStoreType==null || StringUtils.isEmpty(trustStoreType)) {
  286.                 trustStoreType = KeystoreType.JKS.getNome();
  287.             }
  288.             try {
  289.                 config.setTrustStore(GestoreKeystoreCaching.getMerlinTruststore(requestInfo, trustStorePath, trustStoreType, trustStorePassword).getTrustStore().getKeystore());
  290.             }catch(Exception e) {
  291.                 throw new KeystoreException(e.getMessage(),e);
  292.             }
  293.             
  294.             String crl = getProperty(p, PROPERTY_HTTPS_TRUST_STORE_CRL, false);
  295.             if(crl!=null && StringUtils.isNotEmpty(crl)) {
  296.                 try {
  297.                     config.setCrlStore(GestoreKeystoreCaching.getCRLCertstore(requestInfo, crl).getCertStore());
  298.                 }catch(Exception e) {
  299.                     throw new KeystoreException(e.getMessage(),e);
  300.                 }
  301.             }
  302.         }
  303.     }
  304.     
  305.     private static void readKeyStoreConfig(RemoteStoreConfig config, Properties p, RequestInfo requestInfo) throws KeystoreException {
  306.         String keyStorePath = getProperty(p, PROPERTY_HTTPS_KEY_STORE, false);  
  307.         if(keyStorePath!=null && StringUtils.isNotEmpty(keyStorePath)) {
  308.             String keyStorePassword = getProperty(p, PROPERTY_HTTPS_KEY_STORE_PASSWORD, true);  
  309.             String keyStoreType = getProperty(p, PROPERTY_HTTPS_KEY_STORE_TYPE, false);
  310.             if(keyStoreType==null || StringUtils.isEmpty(keyStoreType)) {
  311.                 keyStoreType = KeystoreType.JKS.getNome();
  312.             }
  313.             
  314.             String keyPassword = getProperty(p, PROPERTY_HTTPS_KEY_PASSWORD, true); 
  315.             String keyAlias = getProperty(p, PROPERTY_HTTPS_KEY_ALIAS, false);  
  316.             
  317.             try {
  318.                 config.setKeyStore(GestoreKeystoreCaching.getMerlinKeystore(requestInfo, keyStorePath,keyStoreType,keyStorePassword,keyPassword).getKeyStore().getKeystore());
  319.             }catch(Exception e) {
  320.                 throw new KeystoreException(e.getMessage(),e);
  321.             }
  322.             config.setKeyAlias(keyAlias);
  323.             config.setKeyPassword(keyPassword); 
  324.         }
  325.     }
  326.     
  327.     private static void readForwardProxyConfig(RemoteStoreConfig config, Properties p) throws KeystoreException {
  328.         String forwardProxyUrl = getProperty(p, PROPERTY_FORWARD_PROXY_URL, false); 
  329.         if(forwardProxyUrl!=null && StringUtils.isNotEmpty(forwardProxyUrl)) {
  330.             config.setForwardProxyUrl(forwardProxyUrl);
  331.             config.setForwardProxyHeader(getProperty(p, PROPERTY_FORWARD_PROXY_HEADER, false)); 
  332.             config.setForwardProxyQueryParameter(getProperty(p, PROPERTY_FORWARD_PROXY_QUERY_PARAMETER, false));
  333.             if(config.getForwardProxyHeader()==null && config.getForwardProxyQueryParameter()==null) {
  334.                 throw new KeystoreException("ForwardProxy property '"+PROPERTY_FORWARD_PROXY_URL+"' require '"+
  335.                         PROPERTY_FORWARD_PROXY_HEADER+"' o '"+
  336.                         PROPERTY_FORWARD_PROXY_QUERY_PARAMETER+"'");
  337.             }
  338.             config.setForwardProxyBase64(getBooleanProperty(p, PROPERTY_FORWARD_PROXY_BASE64, false, true));
  339.         }
  340.     }
  341.     
  342.     private static String getProperty(Properties p, String name, boolean required) throws KeystoreException {
  343.         String tmp = p.getProperty(name);
  344.         if(tmp!=null) {
  345.             return tmp.trim();
  346.         }
  347.         else {
  348.             if(required) {
  349.                 throw new KeystoreException("Property '"+name+"' notFound");
  350.             }
  351.             return null;
  352.         }
  353.     }
  354.     private static boolean getBooleanProperty(Properties p, String name, boolean required, boolean defaultValue) throws KeystoreException {
  355.         String tmp = getProperty(p, name, required);
  356.         if(tmp!=null && StringUtils.isNotEmpty(tmp)) {
  357.             try {
  358.                 return Boolean.valueOf(tmp);
  359.             }catch(Exception t) {
  360.                 throw new KeystoreException("Boolean property '"+name+"' invalid (found value:["+tmp+"]): "+t.getMessage(),t);
  361.             }
  362.         }
  363.         return defaultValue;
  364.     }
  365.     private static int getIntProperty(Properties p, String name, boolean required, int defaultValue) throws KeystoreException {
  366.         String tmp = getProperty(p, name, required);
  367.         if(tmp!=null && StringUtils.isNotEmpty(tmp)) {
  368.             try {
  369.                 return Integer.valueOf(tmp);
  370.             }catch(Exception t) {
  371.                 throw new KeystoreException("Boolean property '"+name+"' invalid (found value:["+tmp+"]): "+t.getMessage(),t);
  372.             }
  373.         }
  374.         return defaultValue;
  375.     }
  376. }
Created with JaCoCo 0.8.8.202204050719