TokenUtilities.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.pdd.core.token;

  24. import java.io.Serializable;
  25. import java.util.ArrayList;
  26. import java.util.HashMap;
  27. import java.util.List;
  28. import java.util.Map;
  29. import java.util.Properties;

  31. import org.apache.commons.lang.StringUtils;
  32. import org.apache.cxf.rt.security.rs.RSSecurityConstants;
  33. import org.openspcoop2.core.commons.DBUtils;
  34. import org.openspcoop2.core.commons.Filtri;
  35. import org.openspcoop2.core.commons.ISearch;
  36. import org.openspcoop2.core.commons.Liste;
  37. import org.openspcoop2.core.commons.Search;
  38. import org.openspcoop2.core.config.GenericProperties;
  39. import org.openspcoop2.core.config.GestioneToken;
  40. import org.openspcoop2.core.config.Property;
  41. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  42. import org.openspcoop2.core.constants.CostantiConnettori;
  43. import org.openspcoop2.core.id.IDGenericProperties;
  44. import org.openspcoop2.core.id.IDServizio;
  45. import org.openspcoop2.core.id.IDSoggetto;
  46. import org.openspcoop2.core.mvc.properties.Item;
  47. import org.openspcoop2.core.mvc.properties.constants.ItemType;
  48. import org.openspcoop2.core.mvc.properties.provider.ExternalResources;
  49. import org.openspcoop2.core.mvc.properties.provider.ProviderException;
  50. import org.openspcoop2.core.mvc.properties.provider.ProviderValidationException;
  51. import org.openspcoop2.core.mvc.properties.utils.DBPropertiesUtils;
  52. import org.openspcoop2.core.mvc.properties.utils.MultiPropertiesUtilities;
  53. import org.openspcoop2.core.plugins.Plugin;
  54. import org.openspcoop2.core.plugins.constants.TipoPlugin;
  55. import org.openspcoop2.core.plugins.utils.PluginsDriverUtils;
  56. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  57. import org.openspcoop2.pdd.config.ForwardProxy;
  58. import org.openspcoop2.pdd.core.dynamic.DynamicMapBuilderUtils;
  59. import org.openspcoop2.pdd.core.token.attribute_authority.PolicyAttributeAuthority;
  60. import org.openspcoop2.protocol.sdk.Busta;
  61. import org.openspcoop2.protocol.sdk.Context;
  62. import org.openspcoop2.protocol.sdk.state.IState;
  63. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  64. import org.openspcoop2.security.message.constants.SecurityConstants;
  65. import org.openspcoop2.security.message.jose.JOSECostanti;
  66. import org.openspcoop2.security.message.utils.AbstractSecurityProvider;
  67. import org.openspcoop2.utils.certificate.KeystoreParams;
  68. import org.openspcoop2.utils.certificate.KeystoreType;
  69. import org.slf4j.Logger;

  71. /**     
  72.  * TokenUtilities
  73.  *
  74.  * @author Poli Andrea (poli@link.it)
  75.  * @author $Author$
  76.  * @version $Rev$, $Date$
  77.  */
  78. public class TokenUtilities {
  79.     
  80.     private TokenUtilities() {}

  82.     public static Properties getDefaultProperties(Map<String, Properties> mapProperties) {
  83.         return MultiPropertiesUtilities.getDefaultProperties(mapProperties);
  84.     }
  85.     public static Properties getDynamicDiscoveryClaimsMappingProperties(Map<String, Properties> mapProperties) {
  86.         return mapProperties.get(Costanti.DYNAMIC_DISCOVERY_PARSER_COLLECTION_ID);
  87.     }
  88.     public static Properties getValidazioneJwtClaimsMappingProperties(Map<String, Properties> mapProperties) {
  89.         return mapProperties.get(Costanti.VALIDAZIONE_JWT_TOKEN_PARSER_COLLECTION_ID);
  90.     }
  91.     public static Properties getIntrospectionClaimsMappingProperties(Map<String, Properties> mapProperties) {
  92.         return mapProperties.get(Costanti.INTROSPECTION_TOKEN_PARSER_COLLECTION_ID);
  93.     }
  94.     public static Properties getUserInfoClaimsMappingProperties(Map<String, Properties> mapProperties) {
  95.         return mapProperties.get(Costanti.USERINFO_TOKEN_PARSER_COLLECTION_ID);
  96.     }
  97.     
  98.     public static Properties getRetrieveResponseClaimsMappingProperties(Map<String, Properties> mapProperties) {
  99.         return mapProperties.get(Costanti.RETRIEVE_TOKEN_PARSER_COLLECTION_ID);
  100.     }
  101.     
  102.     public static List<String> getClaims(Properties p, String name) {
  103.         String v = p.getProperty(name);
  104.         List<String> l = new ArrayList<>();
  105.         if(v!=null) {
  106.             if(v.contains(",")) {
  107.                 String [] tmp = v.split(",");
  108.                 for (String s : tmp) {
  109.                     if(StringUtils.isNotEmpty(s.trim())) {
  110.                         l.add(s.trim());
  111.                     }
  112.                 }
  113.             }
  114.             else {
  115.                 l.add(v.trim());
  116.             }
  117.         }
  118.         return l;
  119.     }
  120.     
  121.     public static Map<String, Properties> getMultiProperties(GenericProperties gp) throws ProviderException {
  122.         Map<String, Properties> multiProperties = null;
  123.         try {
  124.             HashMap<String, String> properties = new HashMap<>();
  125.             for (Property pConfig : gp.getPropertyList()) {
  126.                 properties.put(pConfig.getNome(), pConfig.getValore());
  127.             }
  128.             multiProperties = DBPropertiesUtils.toMultiMap(properties);
  129.         }catch(Exception e) {
  130.             throw new ProviderException(e.getMessage(),e);
  131.         }
  132.         return multiProperties;
  133.     }

  135.     public static boolean isDynamicDiscoveryEnabled(Map<String, Properties> mapProperties) {
  136.         return isDynamicDiscoveryEnabled(getDefaultProperties(mapProperties));
  137.     }
  138.     public static boolean isDynamicDiscoveryEnabled(Properties pDefault) {
  139.         return isEnabled(pDefault, Costanti.POLICY_DISCOVERY_STATO);
  140.     }
  141.     public static boolean isDynamicDiscoveryEnabled(GenericProperties gp) throws ProviderException {
  142.         Map<String, Properties> multiProperties = getMultiProperties(gp);
  143.         return isDynamicDiscoveryEnabled(multiProperties);
  144.     }
  145.     
  146.     public static boolean isValidazioneEnabled(Map<String, Properties> mapProperties) {
  147.         return isValidazioneEnabled(getDefaultProperties(mapProperties));
  148.     }
  149.     public static boolean isValidazioneEnabled(Properties pDefault) {
  150.         return isEnabled(pDefault, Costanti.POLICY_VALIDAZIONE_STATO);
  151.     }
  152.     public static boolean isValidazioneEnabled(GenericProperties gp) throws ProviderException {
  153.         Map<String, Properties> multiProperties = getMultiProperties(gp);
  154.         return isValidazioneEnabled(multiProperties);
  155.     }
  156.         
  157.     public static boolean isIntrospectionEnabled(Map<String, Properties> mapProperties) {
  158.         return isIntrospectionEnabled(getDefaultProperties(mapProperties));
  159.     }
  160.     public static boolean isIntrospectionEnabled(Properties pDefault) {
  161.         return isEnabled(pDefault, Costanti.POLICY_INTROSPECTION_STATO);
  162.     }
  163.     public static boolean isIntrospectionEnabled(GenericProperties gp) throws ProviderException {
  164.         Map<String, Properties> multiProperties = getMultiProperties(gp);
  165.         return isIntrospectionEnabled(multiProperties);
  166.     }
  167.     
  168.     public static boolean isUserInfoEnabled(Map<String, Properties> mapProperties) {
  169.         return isUserInfoEnabled(getDefaultProperties(mapProperties));
  170.     }
  171.     public static boolean isUserInfoEnabled(Properties pDefault) {
  172.         return isEnabled(pDefault, Costanti.POLICY_USER_INFO_STATO);
  173.     }
  174.     public static boolean isUserInfoEnabled(GenericProperties gp) throws ProviderException {
  175.         Map<String, Properties> multiProperties = getMultiProperties(gp);
  176.         return isUserInfoEnabled(multiProperties);
  177.     }
  178.     
  179.     public static boolean isTokenForwardEnabled(Map<String, Properties> mapProperties) {
  180.         return isTokenForwardEnabled(getDefaultProperties(mapProperties));
  181.     }
  182.     public static boolean isTokenForwardEnabled(Properties pDefault) {
  183.         return isEnabled(pDefault, Costanti.POLICY_TOKEN_FORWARD_STATO);
  184.     }
  185.     public static boolean isTokenForwardEnabled(GenericProperties gp) throws ProviderException {
  186.         Map<String, Properties> multiProperties = getMultiProperties(gp);
  187.         return isTokenForwardEnabled(multiProperties);
  188.     }
  189.     
  190.     public static boolean isEnabled(Properties p, String propertyName) {
  191.         return MultiPropertiesUtilities.isEnabled(p, propertyName);
  192.     }
  193.     
  194.     private static String getPrefixPolicy(GenericProperties gp) {
  195.         return "La configurazione nella policy "+gp.getNome();
  196.     }
  197.     
  198.     public static KeystoreParams getValidazioneJwtKeystoreParams(GenericProperties gp) throws TokenException, ProviderException, ProviderValidationException {
  199.         PolicyGestioneToken policy = TokenUtilities.convertTo(gp, new GestioneToken());
  200.         if(!TokenUtilities.isValidazioneEnabled(gp)) {
  201.             throw new TokenException(getPrefixPolicy(gp)+" non utilizza la funzionalità di validazione JWT");
  202.         }
  203.         return getValidazioneJwtKeystoreParams(policy);
  204.     }
  205.     public static KeystoreParams getValidazioneJwtKeystoreParams(PolicyGestioneToken policy) throws TokenException {
  206.         String tokenType = policy.getTipoToken();
  207.         Properties p = null;
  208.         if(org.openspcoop2.pdd.core.token.Costanti.POLICY_TOKEN_TYPE_JWS.equals(tokenType)) {
  209.             // JWS Compact              
  210.             p = policy.getProperties().get(org.openspcoop2.pdd.core.token.Costanti.POLICY_VALIDAZIONE_JWS_VERIFICA_PROP_REF_ID);
  211.         }
  212.         else if(org.openspcoop2.pdd.core.token.Costanti.POLICY_TOKEN_TYPE_JWE.equals(tokenType)) {
  213.             // JWE Compact
  214.             p = policy.getProperties().get(org.openspcoop2.pdd.core.token.Costanti.POLICY_VALIDAZIONE_JWE_DECRYPT_PROP_REF_ID);
  215.         }
  216.         if(p!=null && p.containsKey(SecurityConstants.JOSE_KEYSTORE_FILE)) {
  217.             KeystoreParams keystoreParams = new KeystoreParams();
  218.             keystoreParams.setPath(p.getProperty(SecurityConstants.JOSE_KEYSTORE_FILE));
  219.             String type = p.getProperty(SecurityConstants.JOSE_KEYSTORE_TYPE);
  220.             if(type==null) {
  221.                 type = KeystoreType.JKS.getNome();
  222.             }
  223.             keystoreParams.setType(type);
  224.             keystoreParams.setPassword(p.getProperty(SecurityConstants.JOSE_KEYSTORE_PSWD));
  225.             keystoreParams.setKeyAlias(p.getProperty(SecurityConstants.JOSE_KEYSTORE_KEY_ALIAS));
  226.             keystoreParams.setKeyPassword(p.getProperty(RSSecurityConstants.RSSEC_KEY_PSWD));
  227.             
  228.             fillKeyPairParamters(keystoreParams, type, p);
  229.             
  230.             return keystoreParams;
  231.         }
  232.         return null;
  233.     }
  234.     private static void fillKeyPairParamters(KeystoreParams keystoreParams, String type, Properties p) throws TokenException {
  235.         if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(type)) {
  236.             String keystorePublicKeyFile = p.getProperty(SecurityConstants.JOSE_KEYSTORE_PUBLIC_KEY);
  237.             if(keystorePublicKeyFile==null) {
  238.                 throw new TokenException("Public key file undefined");
  239.             }
  240.             keystoreParams.setKeyPairPublicKeyPath(keystorePublicKeyFile);
  241.         }
  242.         
  243.         if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(type)
  244.                 ||
  245.             SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(type)) {
  246.             String keyPairAlgorithm = p.getProperty(SecurityConstants.JOSE_KEYSTORE_KEY_ALGORITHM);
  247.             if(keyPairAlgorithm==null) {
  248.                 throw new TokenException("Key pair algorithm undefined");
  249.             }
  250.             keystoreParams.setKeyPairAlgorithm(keyPairAlgorithm);
  251.         }
  252.     }
  253.     
  254.     public static KeystoreParams getForwardToJwtKeystoreParams(GenericProperties gp) throws TokenException, ProviderException, ProviderValidationException {
  255.         PolicyGestioneToken policy = TokenUtilities.convertTo(gp, new GestioneToken());
  256.         if(!TokenUtilities.isTokenForwardEnabled(gp) || !policy.isForwardTokenInformazioniRaccolte()) {
  257.             throw new TokenException(getPrefixPolicy(gp)+" non utilizza la funzionalità di forward delle informazioni raccolte del token");
  258.         }
  259.         return getForwardToJwtKeystoreParams(policy);
  260.     }
  261.     public static KeystoreParams getForwardToJwtKeystoreParams(PolicyGestioneToken policy) throws TokenException {
  262.         String forwardInformazioniRaccolteMode = policy.getForwardTokenInformazioniRaccolteMode();
  263.         Properties p = null;
  264.         if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_OP2_JWS.equals(forwardInformazioniRaccolteMode) ||
  265.                 Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JWS.equals(forwardInformazioniRaccolteMode)) {
  266.             // JWS Compact              
  267.             p = policy.getProperties().get(org.openspcoop2.pdd.core.token.Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_SIGNATURE_PROP_REF_ID);
  268.         }
  269.         else if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JWE.equals(forwardInformazioniRaccolteMode)) {
  270.             // JWE Compact
  271.             p = policy.getProperties().get(org.openspcoop2.pdd.core.token.Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_ENCRYP_PROP_REF_ID);
  272.         }
  273.         if(p!=null && p.containsKey(SecurityConstants.JOSE_KEYSTORE_FILE)) {
  274.             KeystoreParams keystoreParams = new KeystoreParams();
  275.             keystoreParams.setPath(p.getProperty(SecurityConstants.JOSE_KEYSTORE_FILE));
  276.             String type = p.getProperty(SecurityConstants.JOSE_KEYSTORE_TYPE);
  277.             if(type==null) {
  278.                 type = KeystoreType.JKS.getNome();
  279.             }
  280.             keystoreParams.setType(type);
  281.             keystoreParams.setPassword(p.getProperty(SecurityConstants.JOSE_KEYSTORE_PSWD));
  282.             keystoreParams.setKeyAlias(p.getProperty(SecurityConstants.JOSE_KEYSTORE_KEY_ALIAS));
  283.             keystoreParams.setKeyPassword(p.getProperty(RSSecurityConstants.RSSEC_KEY_PSWD));
  284.             keystoreParams.setByokPolicy(p.getProperty(SecurityConstants.JOSE_KEYSTORE_BYOK_POLICY));
  285.             
  286.             fillKeyPairParamters(keystoreParams, type, p);
  287.             
  288.             return keystoreParams;
  289.         }
  290.         return null;
  291.     }
  292.     
  293.     public static PolicyGestioneToken convertTo(GenericProperties gp, GestioneToken gestioneToken) throws ProviderException, ProviderValidationException { 
  294.     
  295.         PolicyGestioneToken policy = new PolicyGestioneToken();
  296.         policy.setName(gp.getNome());
  297.         policy.setDescrizione(gp.getDescrizione());
  298.         
  299.         Map<String, Properties> multiProperties = TokenUtilities.getMultiProperties(gp);
  300.         policy.setProperties(multiProperties);
  301.         
  302.         policy.setTokenOpzionale(false);
  303.         
  304.         policy.setDynamicDiscovery(false);
  305.         
  306.         policy.setValidazioneJWT(false);
  307.         policy.setValidazioneJWTWarningOnly(false);
  308.         
  309.         policy.setIntrospection(false);
  310.         policy.setIntrospectionWarningOnly(false);
  311.         
  312.         policy.setUserInfo(false);
  313.         policy.setUserInfoWarningOnly(false);
  314.         
  315.         policy.setForwardToken(false);
  316.         
  317.         if(gestioneToken!=null) {
  318.             fill(policy, gestioneToken, multiProperties);
  319.         }
  320.         
  321.         return policy;

  323.     }
  324.     private static void fill(PolicyGestioneToken policy, GestioneToken gestioneToken, Map<String, Properties> multiProperties) {
  325.         if(gestioneToken.getTokenOpzionale()!=null) {
  326.             policy.setTokenOpzionale(org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO.equals(gestioneToken.getTokenOpzionale()));
  327.         }
  328.         
  329.         boolean dynamicDiscoveryEnabledDaPolicy = isDynamicDiscoveryEnabled(multiProperties);
  330.         policy.setDynamicDiscovery(dynamicDiscoveryEnabledDaPolicy);
  331.         
  332.         boolean validazioneEnabledDaPolicy = isValidazioneEnabled(multiProperties);
  333.         if(validazioneEnabledDaPolicy &&
  334.             gestioneToken.getValidazione()!=null) {
  335.             switch (gestioneToken.getValidazione()) {
  336.             case ABILITATO:
  337.                 policy.setValidazioneJWT(true);
  338.                 policy.setValidazioneJWTWarningOnly(false);
  339.                 break;
  340.             case WARNING_ONLY:
  341.                 policy.setValidazioneJWT(true);
  342.                 policy.setValidazioneJWTWarningOnly(true);
  343.                 break;
  344.             case DISABILITATO:
  345.                 policy.setValidazioneJWT(false);
  346.                 policy.setValidazioneJWTWarningOnly(false);
  347.                 break;
  348.             }
  349.         }
  350.         
  351.         boolean introspectionEnabledDaPolicy = isIntrospectionEnabled(multiProperties);
  352.         if(introspectionEnabledDaPolicy &&
  353.             gestioneToken.getIntrospection()!=null) {
  354.             switch (gestioneToken.getIntrospection()) {
  355.             case ABILITATO:
  356.                 policy.setIntrospection(true);
  357.                 policy.setIntrospectionWarningOnly(false);
  358.                 break;
  359.             case WARNING_ONLY:
  360.                 policy.setIntrospection(true);
  361.                 policy.setIntrospectionWarningOnly(true);
  362.                 break;
  363.             case DISABILITATO:
  364.                 policy.setIntrospection(false);
  365.                 policy.setIntrospectionWarningOnly(false);
  366.                 break;
  367.             }
  368.         }
  369.         
  370.         boolean userInfoEnabledDaPolicy = isUserInfoEnabled(multiProperties);
  371.         if(userInfoEnabledDaPolicy &&
  372.             gestioneToken.getUserInfo()!=null) {
  373.             switch (gestioneToken.getUserInfo()) {
  374.             case ABILITATO:
  375.                 policy.setUserInfo(true);
  376.                 policy.setUserInfoWarningOnly(false);
  377.                 break;
  378.             case WARNING_ONLY:
  379.                 policy.setUserInfo(true);
  380.                 policy.setUserInfoWarningOnly(true);
  381.                 break;
  382.             case DISABILITATO:
  383.                 policy.setUserInfo(false);
  384.                 policy.setUserInfoWarningOnly(false);
  385.                 break;
  386.             }
  387.         }
  388.         
  389.         boolean forwardEnabledDaPolicy = isTokenForwardEnabled(multiProperties);
  390.         if(forwardEnabledDaPolicy &&
  391.             gestioneToken.getForward()!=null) {
  392.             policy.setForwardToken(org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO.equals(gestioneToken.getForward()));
  393.         }
  394.     }
  395.     
  396.     
  397.     public static List<String> getClaimValues(Object value) {
  398.         List<String> lRet = null;
  399.         if(value!=null) {
  400.             if(value instanceof List<?>) {
  401.                 List<?> l = (List<?>) value;
  402.                 return getClaimValues(l);
  403.             }
  404.             else {
  405.                 String sValue = value.toString();
  406.                 List<String> l = new ArrayList<>();
  407.                 l.add(sValue);
  408.                 return l;
  409.             }
  410.         }
  411.         return lRet;
  412.     }
  413.     private static List<String> getClaimValues(List<?> l) {
  414.         List<String> lRet = null;
  415.         if(!l.isEmpty()) {
  416.             List<String> lString = new ArrayList<>();
  417.             for (Object o : l) {
  418.                 if(o!=null) {
  419.                     lString.add(o.toString());
  420.                 }
  421.             }
  422.             if(!lString.isEmpty()) {
  423.                 return lString;
  424.             }
  425.         }
  426.         return lRet;
  427.     }
  428.     
  429.     public static String getClaimValuesAsString(List<String> claimValues) {
  430.         StringBuilder claimValueSB = new StringBuilder();
  431.         if(claimValues==null || claimValues.isEmpty()) {
  432.             return null;
  433.         }
  434.         if(claimValues.size()>1) {
  435.             for (String c : claimValues) {
  436.                 if(claimValueSB.length()>0) {
  437.                     claimValueSB.append(",");
  438.                 }
  439.                 claimValueSB.append(c);
  440.             }
  441.         }
  442.         else {
  443.             claimValueSB.append(claimValues.get(0));
  444.         }
  445.         return claimValueSB.length()>0 ? claimValueSB.toString() : null;
  446.     }
  447.     
  448.     public static String getClaimAsString(Map<String, Serializable> claims, String claim) {
  449.         List<String> l = getClaimAsList(claims, claim);
  450.         if(l==null || l.isEmpty()) {
  451.             return null;
  452.         }
  453.         return TokenUtilities.getClaimValuesAsString(l);
  454.     }
  455.     public static List<String> getClaimAsList(Map<String, Serializable> claims, String claim) {
  456.         List<String> l = null;
  457.         Object o = claims.get(claim);
  458.         if(o==null) {
  459.             return l;
  460.         }
  461.         l = TokenUtilities.getClaimValues(o);
  462.         List<String> lRet = null;
  463.         if(l!=null && l.isEmpty()) {
  464.             return lRet;
  465.         }
  466.         return l;
  467.     }
  468.     
  469.     public static String getFirstClaimAsString(Map<String, Serializable> claims, List<String> names) {
  470.         for (String name : names) {
  471.             String claim = getClaimAsString(claims, name);
  472.             if(claim!=null) {
  473.                 return claim;
  474.             }
  475.         }
  476.         return null;
  477.     }
  478.     public static List<String> getFirstClaimAsList(Map<String, Serializable> claims, List<String> names) {
  479.         List<String> lRet = null;
  480.         for (String name : names) {
  481.             List<String> l = getClaimAsList(claims, name);
  482.             if(l!=null && !l.isEmpty()) {
  483.                 return l;
  484.             }
  485.         }
  486.         return lRet;
  487.     }
  488.     
  489.     public static KeystoreParams getSignedJwtKeystoreParams(GenericProperties gp) throws Exception {
  490.         PolicyNegoziazioneToken policy = TokenUtilities.convertTo(gp);
  491.         return getSignedJwtKeystoreParams(policy);
  492.     }
  493.     public static KeystoreParams getSignedJwtKeystoreParams(PolicyNegoziazioneToken policy) throws TokenException {
  494.     
  495.         if(!policy.isRfc7523x509Grant()) {
  496.             throw new TokenException("La configurazione nella policy "+policy.getName()+" non utilizza la funzionalità SignedJWT (RFC 7523)");
  497.         }
  498.         
  499.         String keystoreType = policy.getJwtSignKeystoreType();
  500.         if(keystoreType==null) {
  501.             throw new TokenException("JWT Signature keystore type undefined");
  502.         }
  503.         String keystoreFile = policy.getJwtSignKeystoreFile();
  504.         if(keystoreFile==null) {
  505.             throw new TokenException("JWT Signature keystore file undefined");
  506.         }
  507.         String keystorePassword = policy.getJwtSignKeystorePassword();
  508.         if(keystorePassword==null && 
  509.                 !SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(keystoreType) && 
  510.                 !SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType) && 
  511.                 !SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(keystoreType)) {
  512.             boolean required = true;
  513.             if(KeystoreType.JKS.isType(keystoreType)) {
  514.                 required = DBUtils.isKeystoreJksPasswordRequired();
  515.             }
  516.             else if(KeystoreType.PKCS12.isType(keystoreType)) {
  517.                 required = DBUtils.isKeystorePkcs12PasswordRequired();
  518.             }
  519.             if(required) {
  520.                 throw new TokenException("JWT Signature keystore password undefined");
  521.             }
  522.         }
  523.         String keyAlias = policy.getJwtSignKeyAlias();
  524.         if(keyAlias==null && 
  525.             !SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType) && 
  526.             !SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(keystoreType)) {
  527.             throw new TokenException("JWT Signature key alias undefined");
  528.         }
  529.         
  530.         String keyPassword = policy.getJwtSignKeyPassword();
  531.         if(keyPassword==null && 
  532.                 !SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(keystoreType) && 
  533.                 !SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType) && 
  534.                 !SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(keystoreType)) {
  535.             boolean required = true;
  536.             if(KeystoreType.JKS.isType(keystoreType)) {
  537.                 required = DBUtils.isKeystoreJksKeyPasswordRequired();
  538.             }
  539.             else if(KeystoreType.PKCS12.isType(keystoreType)) {
  540.                 required = DBUtils.isKeystorePkcs12KeyPasswordRequired();
  541.             }
  542.             if(required) {
  543.                 throw new TokenException("JWT Signature key password undefined");
  544.             }
  545.         }
  546.         
  547.         String keystoreByokPolicy = policy.getJwtSignKeystoreByokPolicy();
  548.         
  549.         KeystoreParams keystoreParams = new KeystoreParams();
  550.         keystoreParams.setPath(keystoreFile);
  551.         keystoreParams.setType(keystoreType);
  552.         keystoreParams.setPassword(keystorePassword);
  553.         keystoreParams.setKeyAlias(keyAlias);
  554.         keystoreParams.setKeyPassword(keyPassword);
  555.         keystoreParams.setByokPolicy(keystoreByokPolicy);
  556.         
  557.         fillKeyPairParamters(keystoreParams, keystoreType, policy);
  558.         
  559.         return keystoreParams;
  560.         
  561.     }
  562.     
  563.     private static void fillKeyPairParamters(KeystoreParams keystoreParams, String keystoreType, PolicyNegoziazioneToken policy) throws TokenException {
  564.         if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType)) {
  565.             String keystorePublicKeyFile = policy.getJwtSignKeystoreFilePublicKey();
  566.             if(keystorePublicKeyFile==null) {
  567.                 throw new TokenException("JWT Signature public key file undefined");
  568.             }
  569.             keystoreParams.setKeyPairPublicKeyPath(keystorePublicKeyFile);
  570.         }
  571.         
  572.         if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType)
  573.                 ||
  574.             SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(keystoreType)) {
  575.             String keyPairAlgorithm = policy.getJwtSignKeyPairAlgorithm();
  576.             if(keyPairAlgorithm==null) {
  577.                 throw new TokenException("JWT Signature key pair algorithm undefined");
  578.             }
  579.             keystoreParams.setKeyPairAlgorithm(keyPairAlgorithm);
  580.         }
  581.     }
  582.     
  583.     public static PolicyNegoziazioneToken convertTo(GenericProperties gp) throws Exception { 
  584.         
  585.         PolicyNegoziazioneToken policy = new PolicyNegoziazioneToken();
  586.         policy.setName(gp.getNome());
  587.         policy.setDescrizione(gp.getDescrizione());
  588.         
  589.         HashMap<String, String> properties = new HashMap<>();
  590.         for (Property pConfig : gp.getPropertyList()) {
  591.             properties.put(pConfig.getNome(), pConfig.getValore());
  592.         }
  593.         Map<String, Properties> multiProperties = DBPropertiesUtils.toMultiMap(properties);
  594.         policy.setProperties(multiProperties);
  595.         
  596.         return policy;

  598.     }
  599.     
  600.     public static void checkClaims(String oggetto, Properties claims, String elemento, List<String> denyClaims, boolean checkSpazi) throws ProviderValidationException {
  601.         if(claims!=null && !claims.isEmpty()) {
  602.             for (Object oClaim : claims.keySet()) {
  603.                 if(oClaim instanceof String) {
  604.                     String claim = (String) oClaim;
  605.                     String value = claims.getProperty(claim);
  606.                     validateClaims(oggetto, elemento, denyClaims, checkSpazi, claim, value);
  607.                 }
  608.             }
  609.         }
  610.     }
  611.     private static void validateClaims(String oggetto, String elemento, List<String> denyClaims, boolean checkSpazi,
  612.             String claim, String value) throws ProviderValidationException {
  613.         String indicato = "indicato nel campo '"+elemento+"'";
  614.         if(denyClaims.contains(claim) || denyClaims.contains(claim.toLowerCase())) {
  615.             throw new ProviderValidationException(oggetto+" '"+claim+"', "+indicato+", non può essere configurato");
  616.         }
  617.         if(value==null || StringUtils.isEmpty(value)) {
  618.             throw new ProviderValidationException(oggetto+" '"+claim+"', "+indicato+", non è valorizzato");
  619.         }
  620.         if(checkSpazi) {
  621.             if(value.contains(" ")) {
  622.                 throw new ProviderValidationException("Non indicare spazi nel "+oggetto+" '"+claim+"', "+indicato+"");
  623.             }
  624.         }
  625.         else {
  626.             if(value.startsWith(" ")) {
  627.                 throw new ProviderValidationException("Il valore del "+oggetto+" '"+claim+"', "+indicato+", non deve iniziare con uno spazio");
  628.             }
  629.             if(value.endsWith(" ")) {
  630.                 throw new ProviderValidationException("Il valore del "+oggetto+" '"+claim+"', "+indicato+", non deve terminare con uno spazio");
  631.             }
  632.         }
  633.     }
  634.     
  635.     public static String deleteSignature(String token) {
  636.         // verifico che sia un JWT
  637.         if(token.contains(".")) {
  638.             String [] tmp = token.split("\\.");
  639.             if(tmp!=null && tmp.length==3 &&
  640.                 tmp[2]!=null) {
  641.                 if(tmp[0]!=null && tmp[1]!=null) {
  642.                     return tmp[0]+"."+tmp[1]+".==SIGNATURE==";
  643.                 }
  644.                 else if(tmp[0]==null && tmp[1]!=null) {
  645.                     return "."+tmp[1]+".==SIGNATURE==";
  646.                 }
  647.                 else if(tmp[0]!=null && tmp[1]==null) {
  648.                     return tmp[0]+"..==SIGNATURE==";
  649.                 }
  650.                 else {
  651.                     return "..==SIGNATURE==";
  652.                 }
  653.             }
  654.         }
  655.         return token;
  656.     }
  657.     public static Map<String, Serializable> replaceTokenInMapByValue(Map<String, Serializable> claims, String valueOriginale, String newValue) {
  658.         
  659.         Map<String, Serializable> newMap = new HashMap<>();
  660.         
  661.         if(claims!=null && !claims.isEmpty()) {
  662.             for (Map.Entry<String,Serializable> entry : claims.entrySet()) {
  663.                 String key = entry.getKey();
  664.                 Serializable o = claims.get(key);
  665.                 if(o instanceof String && valueOriginale.equals(o)) {
  666.                     newMap.put(key, newValue);
  667.                 }
  668.                 else {
  669.                     newMap.put(key, o);
  670.                 }
  671.             }
  672.         }
  673.         
  674.         return newMap;
  675.     }
  676.     
  677.     private static final String EXTERNAL_RESOURCE_UNDEFINED = "External resource undefined";
  678.     private static final String RECUPERO_PLUGIN_REGISTRATI_FALLITO_PREFIX = "Recupero plugin registrati fallito: ";
  679.     
  680.     public static List<String> getTokenPluginValues(ExternalResources externalResources, TipoPlugin tipoPlugin) throws ProviderException{
  681.         return getTokenPluginList(externalResources, tipoPlugin, true);
  682.     }
  683.     public static List<String> getTokenPluginLabels(ExternalResources externalResources, TipoPlugin tipoPlugin) throws ProviderException{
  684.         return getTokenPluginList(externalResources, tipoPlugin, false);
  685.     }
  686.     private static List<String> getTokenPluginList(ExternalResources externalResources, TipoPlugin tipoPlugin, boolean value) throws ProviderException{
  687.         if(externalResources==null) {
  688.             throw new ProviderException(EXTERNAL_RESOURCE_UNDEFINED);
  689.         }
  690.         ISearch ricerca = new Search(true);
  691.         ricerca.addFilter(Liste.CONFIGURAZIONE_PLUGINS_CLASSI,  Filtri.FILTRO_TIPO_PLUGIN_CLASSI, tipoPlugin.toString());
  692.         List<Plugin> list = null;
  693.         try {
  694.             list = PluginsDriverUtils.pluginsClassiList(ricerca, externalResources.getConnection(), externalResources.getLog(), externalResources.getTipoDB());
  695.         }catch(Exception t) {
  696.             throw new ProviderException(RECUPERO_PLUGIN_REGISTRATI_FALLITO_PREFIX+t.getMessage(),t);
  697.         }
  698.         List<String> values = new ArrayList<>();
  699.         values.add(CostantiConfigurazione.POLICY_ID_NON_DEFINITA);
  700.         if(list!=null && !list.isEmpty()) {
  701.             for (Plugin plugin : list) {
  702.                 if(plugin.isStato()) {
  703.                     if(value) {
  704.                         values.add(plugin.getTipo());
  705.                     }
  706.                     else {
  707.                         values.add(plugin.getLabel());
  708.                     }
  709.                 }
  710.             }
  711.         }
  712.         
  713.         return values;
  714.     }
  715.     
  716.     public static String dynamicUpdateTokenPluginChoice(ExternalResources externalResources, TipoPlugin tipoPlugin, Item item, String actualValue) {
  717.         try {
  718.             if(externalResources==null) {
  719.                 throw new ProviderException(EXTERNAL_RESOURCE_UNDEFINED);
  720.             }
  721.             ISearch ricerca = new Search(true);
  722.             ricerca.addFilter(Liste.CONFIGURAZIONE_PLUGINS_CLASSI,  Filtri.FILTRO_TIPO_PLUGIN_CLASSI, tipoPlugin.toString());
  723.             List<Plugin> listTmp = pluginsClassiList(ricerca, externalResources);
  724.             List<Plugin> list = null;
  725.             if(listTmp!=null && !listTmp.isEmpty()) {
  726.                 list = new ArrayList<>();
  727.                 for (Plugin p : listTmp) {
  728.                     if(p.isStato()) {   
  729.                         list.add(p);
  730.                     }
  731.                 }
  732.             }
  733.             if(list==null || list.isEmpty()) {
  734.                 item.setType(ItemType.HIDDEN);
  735.                 item.setValue(CostantiConfigurazione.POLICY_ID_NON_DEFINITA);
  736.                 return CostantiConfigurazione.POLICY_ID_NON_DEFINITA;
  737.             }
  738.             else {
  739.                 item.setType(ItemType.SELECT);
  740.                 item.setValue(actualValue);
  741.                 return actualValue;
  742.             }
  743.         }catch(Exception t) {
  744.             // ignore
  745.             return actualValue;
  746.         }
  747.     }
  748.     private static List<Plugin> pluginsClassiList(ISearch ricerca, ExternalResources externalResources) throws ProviderException{
  749.         try {
  750.             return PluginsDriverUtils.pluginsClassiList(ricerca, externalResources.getConnection(), externalResources.getLog(), externalResources.getTipoDB());
  751.         }catch(Exception t) {
  752.             throw new ProviderException(RECUPERO_PLUGIN_REGISTRATI_FALLITO_PREFIX+t.getMessage(),t);
  753.         }
  754.     }
  755.     public static String dynamicUpdateTokenPluginClassName(ExternalResources externalResources, TipoPlugin tipoPlugin, 
  756.             List<?> items, Map<String, String> mapNameValue, Item item, 
  757.             String idChoice, String actualValue) {
  758.         try {
  759.             if(externalResources==null) {
  760.                 throw new ProviderException(EXTERNAL_RESOURCE_UNDEFINED);
  761.             }
  762.             
  763.             List<Plugin> list = fillListTipoPlugin(externalResources, tipoPlugin);
  764.             
  765.             return dynamicUpdateTokenPluginClassName(list, 
  766.                     items, mapNameValue, item, 
  767.                     idChoice, actualValue);
  768.             
  769.         }catch(Exception t) {
  770.             // ignore
  771.         }
  772.         return actualValue;
  773.     }
  774.     private static List<Plugin> fillListTipoPlugin(ExternalResources externalResources, TipoPlugin tipoPlugin) throws ProviderException {
  775.         ISearch ricerca = new Search(true);
  776.         ricerca.addFilter(Liste.CONFIGURAZIONE_PLUGINS_CLASSI,  Filtri.FILTRO_TIPO_PLUGIN_CLASSI, tipoPlugin.toString());
  777.         List<Plugin> listTmp = pluginsClassiList(ricerca, externalResources);
  778.         List<Plugin> list = null;
  779.         if(listTmp!=null && !listTmp.isEmpty()) {
  780.             list = new ArrayList<>();
  781.             for (Plugin p : listTmp) {
  782.                 if(p.isStato()) {   
  783.                     list.add(p);
  784.                 }
  785.             }
  786.         }
  787.         return list;
  788.     }
  789.     private static String dynamicUpdateTokenPluginClassName(List<Plugin> list, 
  790.             List<?> items, Map<String, String> mapNameValue, Item item, 
  791.             String idChoice, String actualValue) {
  792.         if(list!=null && !list.isEmpty()) {
  793.             item.setRequired(false);
  794.             
  795.             if(actualValue==null) {
  796.                 item.setType(ItemType.HIDDEN);
  797.                 item.setValue(CostantiConfigurazione.POLICY_ID_NON_DEFINITA);
  798.                 return CostantiConfigurazione.POLICY_ID_NON_DEFINITA;
  799.             }
  800.             else {
  801.                 String pluginSelected = AbstractSecurityProvider.readValue(idChoice, items, mapNameValue);
  802.                 if(pluginSelected!=null && !StringUtils.isEmpty(pluginSelected) && !CostantiConfigurazione.POLICY_ID_NON_DEFINITA.equals(pluginSelected)) {
  803.                     item.setType(ItemType.HIDDEN);
  804.                     item.setValue(CostantiConfigurazione.POLICY_ID_NON_DEFINITA);
  805.                     return CostantiConfigurazione.POLICY_ID_NON_DEFINITA;
  806.                 }
  807.             }
  808.             
  809.             if(StringUtils.isNotEmpty(actualValue) && !CostantiConfigurazione.POLICY_ID_NON_DEFINITA.equals(actualValue)) {
  810.                 item.setType(ItemType.TEXT);
  811.             }
  812.         }
  813.         else {
  814.             item.setType(ItemType.TEXT);
  815.             item.setRequired(true);
  816.         }
  817.         return actualValue;
  818.     }
  819.     
  820.     
  821.     
  822.     
  823.     public static HashMap<String, Serializable> toHashMapSerializable(Map<String, Serializable> map) {
  824.         HashMap<String, Serializable> mapNull = null;
  825.         if(map instanceof HashMap) {
  826.             return (HashMap<String, Serializable>) map;
  827.         }
  828.         else if(map!=null) {
  829.             HashMap<String, Serializable> sMap = new HashMap<>();
  830.             for (Map.Entry<String,Serializable> entry : map.entrySet()) {
  831.                 sMap.put(entry.getKey(), entry.getValue());
  832.             }
  833.         }
  834.         return mapNull;
  835.     }
  836.     
  837.     public static String readJtiFromInformazioniToken(Context context) {
  838.         Object oInformazioniTokenNormalizzate = null;
  839.         if(context!=null) {
  840.             oInformazioniTokenNormalizzate = context.getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_INFORMAZIONI_NORMALIZZATE);
  841.         }
  842.         InformazioniToken informazioniTokenNormalizzate = null;
  843.         String jtiClaimReceived = null;
  844.         if(oInformazioniTokenNormalizzate!=null) {
  845.             informazioniTokenNormalizzate = (InformazioniToken) oInformazioniTokenNormalizzate;
  846.             jtiClaimReceived = informazioniTokenNormalizzate.getJti();
  847.         }
  848.         return jtiClaimReceived;
  849.     }
  850.     
  851.     
  852.     
  853.     
  854.     public static Map<String, Object> buildDynamicMap(Busta busta, 
  855.             RequestInfo requestInfo, Context pddContext, Logger log) {
  856.         return DynamicMapBuilderUtils.buildDynamicMap(busta, requestInfo, pddContext, log);
  857.     }
  858.     public static String convertDynamicPropertyValue(String v, String nome, Map<String, Object> dynamicMap, Context context) throws TokenException {
  859.         return DynamicMapBuilderUtils.convertDynamicPropertyValue(v, nome, dynamicMap, context);
  860.     }
  861.     
  862.     
  863.     
  864.     
  865.     
  866.     
  867.     
  868.     
  869.     
  870.     
  871.     public static void injectJOSEConfig(Properties p, AbstractPolicyToken policyToken, DynamicDiscovery dynamicDiscovery,
  872.             Busta busta, IDSoggetto idDominio, IDServizio idServizio,
  873.             Context context, Logger log,
  874.             RequestInfo requestInfo, IState state, boolean delegata) throws TokenException {
  875.         
  876.         Map<String, Object> dynamicMap = TokenUtilities.buildDynamicMap(busta, requestInfo, context, log);
  877.         
  878.         if(policyToken instanceof PolicyGestioneToken) {
  879.             injectJOSEConfigDynamicDiscovery(p, (PolicyGestioneToken)policyToken, dynamicDiscovery,
  880.                     dynamicMap, context);
  881.         }
  882.         injectJOSEConfigKeystore(p,  
  883.                 dynamicMap, context);
  884.         injectJOSEConfigSsl(p, policyToken, 
  885.                 dynamicMap, context);
  886.         injectJOSEConfigTimeout(p, policyToken, 
  887.                 dynamicMap, context);
  888.         injectJOSEConfigProxy(p, policyToken, 
  889.                 dynamicMap, context);
  890.         injectJOSEConfigForwardProxy(p, policyToken, 
  891.                 idDominio, idServizio,
  892.                 requestInfo, state, delegata);
  893.     }
  894.     private static void injectJOSEConfigDynamicDiscovery(Properties p, PolicyGestioneToken policyGestioneToken, DynamicDiscovery dynamicDiscovery,
  895.             Map<String, Object> dynamicMap, Context context) throws TokenException {
  896.         if(policyGestioneToken.isDynamicDiscovery()) {
  897.             GestoreTokenValidazioneUtilities.check(dynamicDiscovery);
  898.             String endpoint = dynamicDiscovery.getJwksUri();
  899.             endpoint = convertDynamicPropertyValue(endpoint, "endpoint", dynamicMap, context);
  900.             if(endpoint==null || StringUtils.isEmpty(endpoint)) {
  901.                 throw new TokenException("DynamicDiscovery.jwkUri undefined");
  902.             }
  903.             p.put(SecurityConstants.JOSE_KEYSTORE_FILE, endpoint);
  904.         }
  905.     }
  906.     private static void injectJOSEConfigKeystore(Properties p, 
  907.             Map<String, Object> dynamicMap, Context context) throws TokenException {
  908.         
  909.         String file = p.getProperty(SecurityConstants.JOSE_KEYSTORE_FILE);
  910.         if(file!=null && !"".equals(file)) {
  911.             file = convertDynamicPropertyValue(file, "file", dynamicMap, context);
  912.             p.put(SecurityConstants.JOSE_KEYSTORE_FILE, file);
  913.         }
  914.         
  915.         String alias = p.getProperty(SecurityConstants.JOSE_KEYSTORE_KEY_ALIAS);
  916.         if(alias!=null && !"".equals(alias)) {
  917.             alias = convertDynamicPropertyValue(alias, "alias", dynamicMap, context);
  918.             p.put(SecurityConstants.JOSE_KEYSTORE_KEY_ALIAS, alias);
  919.         }
  920.         
  921.         String pwd = p.getProperty(SecurityConstants.JOSE_KEYSTORE_PSWD);
  922.         if(pwd!=null && !"".equals(pwd)) {
  923.             pwd = convertDynamicPropertyValue(pwd, "pwd", dynamicMap, context);
  924.             p.put(SecurityConstants.JOSE_KEYSTORE_PSWD, pwd);
  925.         }
  926.         
  927.         String type = p.getProperty(SecurityConstants.JOSE_KEYSTORE_TYPE);
  928.         if(type!=null && !"".equals(type)) {
  929.             type = convertDynamicPropertyValue(type, "type", dynamicMap, context);
  930.             p.put(SecurityConstants.JOSE_KEYSTORE_TYPE, type);
  931.         }
  932.         
  933.     }
  934.     public static void injectJOSEConfigSsl(Properties p, AbstractPolicyToken policyToken,
  935.             Map<String, Object> dynamicMap, Context context) throws TokenException {
  936.         boolean https = false;
  937.         if(policyToken instanceof PolicyGestioneToken) {
  938.             https = ((PolicyGestioneToken)policyToken).isEndpointHttps();
  939.         }
  940.         else if(policyToken instanceof PolicyAttributeAuthority) {
  941.             try {
  942.                 https = ((PolicyAttributeAuthority)policyToken).isEndpointHttps();
  943.             }catch(Exception e) {
  944.                 throw new TokenException(e.getMessage(),e);
  945.             }
  946.         }
  947.         if(https) {
  948.             Properties sslConfig = policyToken.getProperties().get(Costanti.POLICY_ENDPOINT_SSL_CONFIG);
  949.             if(sslConfig!=null) {
  950.                 injectJOSEConfigSsl(p, sslConfig,
  951.                         dynamicMap, context);
  952.             }
  953.         }
  954.     }
  955.     private static void injectJOSEConfigSsl(Properties p, Properties sslConfig,
  956.             Map<String, Object> dynamicMap, Context context) throws TokenException {
  957.         String trustAll = sslConfig.getProperty(CostantiConnettori.CONNETTORE_HTTPS_TRUST_ALL_CERTS);
  958.         if(trustAll!=null && StringUtils.isNotEmpty(trustAll) && "true".equalsIgnoreCase(trustAll)) {
  959.             p.put(JOSECostanti.ID_TRUSTSTORE_SSL_KEYSTORE_TRUSTALL, trustAll);
  960.         }
  961.         else {
  962.             injectJOSEConfigSslTrustStore(p, sslConfig,
  963.                     dynamicMap, context);
  964.         }
  965.         
  966.         String hostnameVerifier = sslConfig.getProperty(CostantiConnettori.CONNETTORE_HTTPS_HOSTNAME_VERIFIER);
  967.         if(hostnameVerifier!=null && StringUtils.isNotEmpty(hostnameVerifier)) {
  968.             p.put(JOSECostanti.ID_TRUSTSTORE_SSL_KEYSTORE_HOSTNAME_VERIFIER, hostnameVerifier);
  969.         }
  970.     }
  971.     private static void injectJOSEConfigSslTrustStore(Properties p, Properties sslConfig,
  972.             Map<String, Object> dynamicMap, Context context) throws TokenException {
  973.         String trustLocation = sslConfig.getProperty(CostantiConnettori.CONNETTORE_HTTPS_TRUST_STORE_LOCATION);
  974.         if(trustLocation!=null && StringUtils.isNotEmpty(trustLocation)) {
  975.             trustLocation = convertDynamicPropertyValue(trustLocation, "trustLocation", dynamicMap, context);
  976.             p.put(JOSECostanti.ID_TRUSTSTORE_SSL_KEYSTORE_FILE, trustLocation);
  977.             
  978.             String trustType = sslConfig.getProperty(CostantiConnettori.CONNETTORE_HTTPS_TRUST_STORE_TYPE);
  979.             if(trustType!=null && StringUtils.isNotEmpty(trustType)) {
  980.                 trustType = convertDynamicPropertyValue(trustType, "trustType", dynamicMap, context);
  981.                 p.put(JOSECostanti.ID_TRUSTSTORE_SSL_KEYSTORE_TYPE, trustType);
  982.             }
  983.             
  984.             String trustPassword = sslConfig.getProperty(CostantiConnettori.CONNETTORE_HTTPS_TRUST_STORE_PASSWORD);
  985.             if(trustPassword!=null && StringUtils.isNotEmpty(trustPassword)) {
  986.                 trustPassword = convertDynamicPropertyValue(trustPassword, "trustPassword", dynamicMap, context);
  987.                 p.put(JOSECostanti.ID_TRUSTSTORE_SSL_KEYSTORE_PASSWORD, trustPassword);
  988.             }
  989.             
  990.             String trustCrl = sslConfig.getProperty(CostantiConnettori.CONNETTORE_HTTPS_TRUST_STORE_CRLS);
  991.             if(trustCrl!=null && StringUtils.isNotEmpty(trustCrl)) {
  992.                 trustCrl = convertDynamicPropertyValue(trustCrl, "trustCrl", dynamicMap, context);
  993.                 p.put(JOSECostanti.ID_TRUSTSTORE_SSL_KEYSTORE_CRL, trustCrl);
  994.             }
  995.         }
  996.     }
  997.     private static void injectJOSEConfigTimeout(Properties p, AbstractPolicyToken policyToken,
  998.             Map<String, Object> dynamicMap, Context context) throws TokenException {
  999.         Properties endpointConfig = policyToken.getProperties().get(Costanti.POLICY_ENDPOINT_CONFIG);
  1000.         if(endpointConfig!=null && endpointConfig.containsKey(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT)) {
  1001.             String connectionTimeout = endpointConfig.getProperty(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT);
  1002.             if(connectionTimeout!=null && StringUtils.isNotEmpty(connectionTimeout)) {
  1003.                 connectionTimeout = convertDynamicPropertyValue(connectionTimeout, "connectionTimeout", dynamicMap, context);
  1004.             }
  1005.             
  1006.             String readTimeout = endpointConfig.getProperty(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT);
  1007.             if(readTimeout!=null && StringUtils.isNotEmpty(readTimeout)) {
  1008.                 readTimeout = convertDynamicPropertyValue(readTimeout, "readTimeout", dynamicMap, context);
  1009.             }
  1010.         
  1011.             if(connectionTimeout!=null) {
  1012.                 p.put(JOSECostanti.ID_TRUSTSTORE_SSL_KEYSTORE_CONNECTION_TIMEOUT, connectionTimeout);
  1013.             }
  1014.             if(readTimeout!=null) {
  1015.                 p.put(JOSECostanti.ID_TRUSTSTORE_SSL_KEYSTORE_READ_TIMEOUT, readTimeout);
  1016.             }
  1017.         }
  1018.     }
  1019.     private static void injectJOSEConfigProxy(Properties p, AbstractPolicyToken policyToken,
  1020.             Map<String, Object> dynamicMap, Context context) throws TokenException {
  1021.         Properties endpointConfig = policyToken.getProperties().get(Costanti.POLICY_ENDPOINT_CONFIG);
  1022.         if(endpointConfig!=null && endpointConfig.containsKey(CostantiConnettori.CONNETTORE_HTTP_PROXY_HOSTNAME)) {
  1023.             String hostProxy = endpointConfig.getProperty(CostantiConnettori.CONNETTORE_HTTP_PROXY_HOSTNAME);
  1024.             if(hostProxy!=null && StringUtils.isNotEmpty(hostProxy)) {
  1025.                 hostProxy = convertDynamicPropertyValue(hostProxy, "hostProxy", dynamicMap, context);
  1026.             }
  1027.             
  1028.             String portProxy = endpointConfig.getProperty(CostantiConnettori.CONNETTORE_HTTP_PROXY_PORT);
  1029.             if(portProxy!=null && StringUtils.isNotEmpty(portProxy)) {
  1030.                 portProxy = convertDynamicPropertyValue(portProxy, "portProxy", dynamicMap, context);
  1031.             }
  1032.         
  1033.             if(hostProxy!=null) {
  1034.                 p.put(JOSECostanti.ID_PROXY_HOSTNAME, hostProxy);
  1035.             }
  1036.             if(portProxy!=null) {
  1037.                 p.put(JOSECostanti.ID_PROXY_PORT, portProxy);
  1038.             }
  1039.             
  1040.             injectJOSEConfigProxyCredentials(p, endpointConfig,
  1041.                     dynamicMap, context);
  1042.         }
  1043.     }
  1044.     private static void injectJOSEConfigProxyCredentials(Properties p, Properties endpointConfig,
  1045.             Map<String, Object> dynamicMap, Context context) throws TokenException {
  1046.         String usernameProxy = endpointConfig.getProperty(CostantiConnettori.CONNETTORE_HTTP_PROXY_USERNAME);
  1047.         String passwordProxy = endpointConfig.getProperty(CostantiConnettori.CONNETTORE_HTTP_PROXY_PASSWORD);
  1048.         if(usernameProxy!=null && StringUtils.isNotEmpty(usernameProxy)) {
  1049.             usernameProxy = convertDynamicPropertyValue(usernameProxy, "usernameProxy", dynamicMap, context);
  1050.             p.put(JOSECostanti.ID_PROXY_USERNAME, usernameProxy);
  1051.             
  1052.             if(passwordProxy!=null && StringUtils.isNotEmpty(passwordProxy)) {
  1053.                 passwordProxy = convertDynamicPropertyValue(passwordProxy, "passwordProxy", dynamicMap, context);
  1054.             }
  1055.             if(passwordProxy!=null) {
  1056.                 p.put(JOSECostanti.ID_PROXY_PASSWORD, passwordProxy);
  1057.             }
  1058.         }
  1059.     }
  1060.     private static void injectJOSEConfigForwardProxy(Properties p, AbstractPolicyToken policyToken,
  1061.             IDSoggetto idDominio, IDServizio idServizio,
  1062.             RequestInfo requestInfo, IState state, boolean delegata) throws TokenException {

  1064.         ForwardProxy forwardProxy = getForwardProxy(policyToken,
  1065.                 requestInfo, state, delegata,
  1066.                 idDominio, idServizio);
  1067.         if(forwardProxy!=null && forwardProxy.isEnabled() && forwardProxy.getConfigToken()!=null) {
  1068.             boolean enabled = false;
  1069.             if(policyToken instanceof PolicyGestioneToken) {
  1070.                 enabled = forwardProxy.getConfigToken().isTokenJwtValidationEnabled();
  1071.             }
  1072.             else if(policyToken instanceof PolicyAttributeAuthority) {
  1073.                 enabled = forwardProxy.getConfigToken().isAttributeAuthorityResponseJwtValidationEnabled();
  1074.             }
  1075.             if(enabled) {
  1076.                 p.put(JOSECostanti.ID_FORWARD_PROXY_ENDPOINT, forwardProxy.getUrl());
  1077.                 if(forwardProxy.getConfig()!=null) {
  1078.                     if(forwardProxy.getConfig().getHeader()!=null) {
  1079.                         p.put(JOSECostanti.ID_FORWARD_PROXY_HEADER, forwardProxy.getConfig().getHeader());
  1080.                         p.put(JOSECostanti.ID_FORWARD_PROXY_HEADER_BASE64, forwardProxy.getConfig().isHeaderBase64()+"");
  1081.                     }
  1082.                     else if(forwardProxy.getConfig().getQuery()!=null) {
  1083.                         p.put(JOSECostanti.ID_FORWARD_PROXY_QUERY, forwardProxy.getConfig().getQuery());
  1084.                         p.put(JOSECostanti.ID_FORWARD_PROXY_QUERY_BASE64, forwardProxy.getConfig().isQueryBase64()+"");
  1085.                     }
  1086.                 }
  1087.             }
  1088.         }
  1089.     }
  1090.     
  1091.     
  1092.     
  1093.     
  1094.     public static ForwardProxy getForwardProxy(AbstractPolicyToken policyToken,
  1095.             RequestInfo requestInfo, IState state, boolean delegata,
  1096.             IDSoggetto idDominio, IDServizio idServizio) throws TokenException{
  1097.         ForwardProxy forwardProxy = null;
  1098.         ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(state);
  1099.         if(configurazionePdDManager.isForwardProxyEnabled(requestInfo)) {
  1100.             try {
  1101.                 IDGenericProperties policy = new IDGenericProperties();
  1102.                 policy.setTipologia(CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_VALIDATION);
  1103.                 policy.setNome(policyToken.getName());
  1104.                 if(delegata) {
  1105.                     forwardProxy = configurazionePdDManager.getForwardProxyConfigFruizione(idDominio, idServizio, policy, requestInfo);
  1106.                 }
  1107.                 else {
  1108.                     forwardProxy = configurazionePdDManager.getForwardProxyConfigErogazione(idDominio, idServizio, policy, requestInfo);
  1109.                 }
  1110.             }catch(Exception e) {
  1111.                 throw new TokenException(GestoreToken.getMessageErroreGovWayProxy(e),e);
  1112.             }
  1113.         }
  1114.         return forwardProxy;
  1115.     }
  1116.     
  1117.     
  1118.     
  1119.     public static void injectSameKeystoreForHttpsClient(Properties sslConfig, Properties sslClientConfig) {
  1120.         if(!sslClientConfig.containsKey(CostantiConnettori.CONNETTORE_HTTPS_KEY_STORE_LOCATION) && !sslClientConfig.containsKey(CostantiConnettori.CONNETTORE_HTTPS_KEY_STORE_PASSWORD)) {
  1121.             // modalita usa valori del truststore
  1122.             String trustStoreLocation = sslConfig.getProperty(CostantiConnettori.CONNETTORE_HTTPS_TRUST_STORE_LOCATION); 
  1123.             String trustStorePassword = sslConfig.getProperty(CostantiConnettori.CONNETTORE_HTTPS_TRUST_STORE_PASSWORD);
  1124.             if(trustStoreLocation!=null) {
  1125.                 sslClientConfig.put(CostantiConnettori.CONNETTORE_HTTPS_KEY_STORE_LOCATION, trustStoreLocation);
  1126.                 if(trustStorePassword!=null) {
  1127.                     sslClientConfig.put(CostantiConnettori.CONNETTORE_HTTPS_TRUST_STORE_PASSWORD, trustStorePassword);
  1128.                 }
  1129.             }
  1130.         }
  1131.     }
  1132. }
Created with JaCoCo 0.8.8.202204050719