ConnettoreHTTPSUtils.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.web.ctrlstat.servlet.connettori;

  22. import java.util.List;

  24. import javax.net.ssl.KeyManagerFactory;
  25. import javax.net.ssl.TrustManagerFactory;

  27. import org.openspcoop2.core.constants.CostantiDB;
  28. import org.openspcoop2.core.registry.constants.StatiAccordo;
  29. import org.openspcoop2.pdd.core.dynamic.DynamicHelperCostanti;
  30. import org.openspcoop2.utils.UtilsException;
  31. import org.openspcoop2.utils.certificate.KeystoreType;
  32. import org.openspcoop2.utils.certificate.byok.BYOKProvider;
  33. import org.openspcoop2.utils.certificate.hsm.HSMUtils;
  34. import org.openspcoop2.utils.certificate.ocsp.OCSPProvider;
  35. import org.openspcoop2.utils.transport.http.SSLUtilities;
  36. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  37. import org.openspcoop2.web.ctrlstat.costanti.CostantiControlStation;
  38. import org.openspcoop2.web.ctrlstat.servlet.ConsoleHelper;
  39. import org.openspcoop2.web.lib.mvc.Costanti;
  40. import org.openspcoop2.web.lib.mvc.DataElement;
  41. import org.openspcoop2.web.lib.mvc.DataElementInfo;
  42. import org.openspcoop2.web.lib.mvc.DataElementType;

  44. /**
  45.  * ConnettoreHTTPSUtils
  46.  *
  47.  * @author Andrea Poli (apoli@link.it)
  48.  * @author $Author$
  49.  * @version $Rev$, $Date$
  50.  */
  51. public class ConnettoreHTTPSUtils {
  52.     
  53.     private ConnettoreHTTPSUtils() {}

  55.     public static void fillConnettoreConfig(org.openspcoop2.core.config.Connettore connettore,
  56.             String httpsurl, String httpstipologia, boolean httpshostverify,
  57.             boolean httpsTrustVerifyCert, String httpspath, String httpstipo, String httpspwd,
  58.             String httpsalgoritmo, boolean httpsstato, String httpskeystore,
  59.             String httpspwdprivatekeytrust, String httpspathkey,
  60.             String httpstipokey, String httpspwdkey,
  61.             String httpspwdprivatekey, String httpsalgoritmokey,
  62.             String httpsKeyAlias, String httpsTrustStoreCRLs, String httpsTrustStoreOCSPPolicy, String httpsKeyStoreBYOKPolicy){
  63.         
  64.         connettore.setCustom(true);
  65.         
  66.         org.openspcoop2.core.config.Property prop = new org.openspcoop2.core.config.Property();
  67.         prop.setNome(CostantiDB.CONNETTORE_HTTPS_LOCATION);
  68.         prop.setValore(httpsurl);
  69.         connettore.addProperty(prop);

  71.         prop = new org.openspcoop2.core.config.Property();
  72.         prop.setNome(CostantiDB.CONNETTORE_HTTPS_SSL_TYPE);
  73.         prop.setValore(httpstipologia);
  74.         connettore.addProperty(prop);

  76.         prop = new org.openspcoop2.core.config.Property();
  77.         prop.setNome(CostantiDB.CONNETTORE_HTTPS_HOSTNAME_VERIFIER);
  78.         prop.setValore(String.valueOf(httpshostverify));
  79.         connettore.addProperty(prop);

  81.         prop = new org.openspcoop2.core.config.Property();
  82.         prop.setNome(CostantiDB.CONNETTORE_HTTPS_TRUST_ALL_CERTS);
  83.         if(httpsTrustVerifyCert) {
  84.             prop.setValore(String.valueOf(false));
  85.         }
  86.         else {
  87.             prop.setValore(String.valueOf(true));
  88.         }
  89.         connettore.addProperty(prop);
  90.         
  91.         if(httpsTrustVerifyCert) {
  92.         
  93.             prop = new org.openspcoop2.core.config.Property();
  94.             prop.setNome(CostantiDB.CONNETTORE_HTTPS_TRUST_STORE_LOCATION);
  95.             prop.setValore(httpspath);
  96.             connettore.addProperty(prop);
  97.     
  98.             prop = new org.openspcoop2.core.config.Property();
  99.             prop.setNome(CostantiDB.CONNETTORE_HTTPS_TRUST_STORE_TYPE);
  100.             prop.setValore(httpstipo);
  101.             connettore.addProperty(prop);
  102.     
  103.             if(httpspwd!=null && !"".equals(httpspwd)) {
  104.                 prop = new org.openspcoop2.core.config.Property();
  105.                 prop.setNome(CostantiDB.CONNETTORE_HTTPS_TRUST_STORE_PASSWORD);
  106.                 prop.setValore(httpspwd);
  107.                 connettore.addProperty(prop);
  108.             }
  109.             
  110.             if(httpsTrustStoreCRLs!=null && !"".equals(httpsTrustStoreCRLs)) {
  111.                 prop = new org.openspcoop2.core.config.Property();
  112.                 prop.setNome(CostantiDB.CONNETTORE_HTTPS_TRUST_STORE_CRLS);
  113.                 prop.setValore(httpsTrustStoreCRLs);
  114.                 connettore.addProperty(prop);
  115.             }
  116.             
  117.             prop = new org.openspcoop2.core.config.Property();
  118.             prop.setNome(CostantiDB.CONNETTORE_HTTPS_TRUST_MANAGEMENT_ALGORITM);
  119.             if (httpsalgoritmo == null || "".equals(httpsalgoritmo))
  120.                 prop.setValore(javax.net.ssl.TrustManagerFactory.getDefaultAlgorithm());
  121.             else
  122.                 prop.setValore(httpsalgoritmo);
  123.             connettore.addProperty(prop);
  124.         
  125.         }
  126.         
  127.         if(httpsTrustStoreOCSPPolicy!=null && !"".equals(httpsTrustStoreOCSPPolicy)) {
  128.             prop = new org.openspcoop2.core.config.Property();
  129.             prop.setNome(CostantiDB.CONNETTORE_HTTPS_TRUST_STORE_OCSP_POLICY);
  130.             prop.setValore(httpsTrustStoreOCSPPolicy);
  131.             connettore.addProperty(prop);
  132.             
  133.             if(!httpsTrustVerifyCert &&
  134.                 httpsTrustStoreCRLs!=null && !"".equals(httpsTrustStoreCRLs)) {
  135.                 prop = new org.openspcoop2.core.config.Property();
  136.                 prop.setNome(CostantiDB.CONNETTORE_HTTPS_TRUST_STORE_CRLS);
  137.                 prop.setValore(httpsTrustStoreCRLs);
  138.                 connettore.addProperty(prop);
  139.             }
  140.         }

  142.         if (httpsstato) {

  144.             prop = new org.openspcoop2.core.config.Property();
  145.             prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_MANAGEMENT_ALGORITM);
  146.             if (httpsalgoritmokey == null || "".equals(httpsalgoritmokey))
  147.                 prop.setValore(javax.net.ssl.KeyManagerFactory.getDefaultAlgorithm());
  148.             else
  149.                 prop.setValore(httpsalgoritmokey);
  150.             connettore.addProperty(prop);


  153.             if (ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE_DEFAULT.equals(httpskeystore)) {
  154.                 if(httpspwdprivatekeytrust!=null && !"".equals(httpspwdprivatekeytrust)) {
  155.                     prop = new org.openspcoop2.core.config.Property();
  156.                     prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_PASSWORD);
  157.                     prop.setValore(httpspwdprivatekeytrust);
  158.                     connettore.addProperty(prop);
  159.                 }

  161.                 prop = new org.openspcoop2.core.config.Property();
  162.                 prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_LOCATION);
  163.                 prop.setValore(httpspath);
  164.                 connettore.addProperty(prop);

  166.                 prop = new org.openspcoop2.core.config.Property();
  167.                 prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_TYPE);
  168.                 prop.setValore(httpstipo);
  169.                 connettore.addProperty(prop);

  171.                 if(httpspwd!=null && !"".equals(httpspwd)) {
  172.                     prop = new org.openspcoop2.core.config.Property();
  173.                     prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_PASSWORD);
  174.                     prop.setValore(httpspwd);
  175.                     connettore.addProperty(prop);
  176.                 }

  178.             } else {
  179.                 prop = new org.openspcoop2.core.config.Property();
  180.                 prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_LOCATION);
  181.                 prop.setValore(httpspathkey);
  182.                 connettore.addProperty(prop);

  184.                 prop = new org.openspcoop2.core.config.Property();
  185.                 prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_TYPE);
  186.                 prop.setValore(httpstipokey);
  187.                 connettore.addProperty(prop);

  189.                 if(httpspwdkey!=null && !"".equals(httpspwdkey)) {
  190.                     prop = new org.openspcoop2.core.config.Property();
  191.                     prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_PASSWORD);
  192.                     prop.setValore(httpspwdkey);
  193.                     connettore.addProperty(prop);
  194.                 }

  196.                 if(httpspwdprivatekey!=null && !"".equals(httpspwdprivatekey)) {
  197.                     prop = new org.openspcoop2.core.config.Property();
  198.                     prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_PASSWORD);
  199.                     prop.setValore(httpspwdprivatekey);
  200.                     connettore.addProperty(prop);
  201.                 }

  203.             }
  204.             
  205.             if(httpsKeyAlias!=null && !"".equals(httpsKeyAlias)) {
  206.                 prop = new org.openspcoop2.core.config.Property();
  207.                 prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_ALIAS);
  208.                 prop.setValore(httpsKeyAlias);
  209.                 connettore.addProperty(prop);
  210.             }
  211.             
  212.             if(httpsKeyStoreBYOKPolicy!=null && !"".equals(httpsKeyStoreBYOKPolicy)) {
  213.                 prop = new org.openspcoop2.core.config.Property();
  214.                 prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_BYOK_POLICY);
  215.                 prop.setValore(httpsKeyStoreBYOKPolicy);
  216.                 connettore.addProperty(prop);
  217.             }
  218.         }
  219.     }
  220.     
  221.     public static void fillConnettoreRegistry(org.openspcoop2.core.registry.Connettore connettore,
  222.             String httpsurl, String httpstipologia, boolean httpshostverify,
  223.             boolean httpsTrustVerifyCert, String httpspath, String httpstipo, String httpspwd,
  224.             String httpsalgoritmo, boolean httpsstato, String httpskeystore,
  225.             String httpspwdprivatekeytrust, String httpspathkey,
  226.             String httpstipokey, String httpspwdkey,
  227.             String httpspwdprivatekey, String httpsalgoritmokey,
  228.             String httpsKeyAlias, String httpsTrustStoreCRLs, String httpsTrustStoreOCSPPolicy, String httpsKeyStoreBYOKPolicy,
  229.             String user, String pwd){
  230.         
  231.         connettore.setCustom(true);
  232.     
  233.         org.openspcoop2.core.registry.Property prop = new org.openspcoop2.core.registry.Property();
  234.         prop.setNome(CostantiDB.CONNETTORE_HTTPS_LOCATION);
  235.         prop.setValore(httpsurl);
  236.         connettore.addProperty(prop);

  238.         if(user!=null){
  239.             prop = new org.openspcoop2.core.registry.Property();
  240.             prop.setNome(CostantiDB.CONNETTORE_USER);
  241.             prop.setValore(user);
  242.             connettore.addProperty(prop);
  243.         }
  244.         
  245.         if(pwd!=null){
  246.             prop = new org.openspcoop2.core.registry.Property();
  247.             prop.setNome(CostantiDB.CONNETTORE_PWD);
  248.             prop.setValore(pwd);
  249.             connettore.addProperty(prop);
  250.         }
  251.         
  252.         prop = new org.openspcoop2.core.registry.Property();
  253.         prop.setNome(CostantiDB.CONNETTORE_HTTPS_SSL_TYPE);
  254.         prop.setValore(httpstipologia);
  255.         connettore.addProperty(prop);

  257.         prop = new org.openspcoop2.core.registry.Property();
  258.         prop.setNome(CostantiDB.CONNETTORE_HTTPS_HOSTNAME_VERIFIER);
  259.         prop.setValore(String.valueOf(httpshostverify));
  260.         connettore.addProperty(prop);

  262.         prop = new org.openspcoop2.core.registry.Property();
  263.         prop.setNome(CostantiDB.CONNETTORE_HTTPS_TRUST_ALL_CERTS);
  264.         if(httpsTrustVerifyCert) {
  265.             prop.setValore(String.valueOf(false));
  266.         }
  267.         else {
  268.             prop.setValore(String.valueOf(true));
  269.         }
  270.         connettore.addProperty(prop);
  271.         
  272.         if(httpsTrustVerifyCert) {
  273.             
  274.             prop = new org.openspcoop2.core.registry.Property();
  275.             prop.setNome(CostantiDB.CONNETTORE_HTTPS_TRUST_STORE_LOCATION);
  276.             prop.setValore(httpspath);
  277.             connettore.addProperty(prop);
  278.     
  279.             prop = new org.openspcoop2.core.registry.Property();
  280.             prop.setNome(CostantiDB.CONNETTORE_HTTPS_TRUST_STORE_TYPE);
  281.             prop.setValore(httpstipo);
  282.             connettore.addProperty(prop);
  283.     
  284.             if(httpspwd!=null && !"".equals(httpspwd)) {
  285.                 prop = new org.openspcoop2.core.registry.Property();
  286.                 prop.setNome(CostantiDB.CONNETTORE_HTTPS_TRUST_STORE_PASSWORD);
  287.                 prop.setValore(httpspwd);
  288.                 connettore.addProperty(prop);
  289.             }
  290.     
  291.             if(httpsTrustStoreCRLs!=null && !"".equals(httpsTrustStoreCRLs)) {
  292.                 prop = new org.openspcoop2.core.registry.Property();
  293.                 prop.setNome(CostantiDB.CONNETTORE_HTTPS_TRUST_STORE_CRLS);
  294.                 prop.setValore(httpsTrustStoreCRLs);
  295.                 connettore.addProperty(prop);
  296.             }
  297.         
  298.             prop = new org.openspcoop2.core.registry.Property();
  299.             prop.setNome(CostantiDB.CONNETTORE_HTTPS_TRUST_MANAGEMENT_ALGORITM);
  300.             if (httpsalgoritmo == null || "".equals(httpsalgoritmo))
  301.                 prop.setValore(javax.net.ssl.TrustManagerFactory.getDefaultAlgorithm());
  302.             else
  303.                 prop.setValore(httpsalgoritmo);
  304.             connettore.addProperty(prop);

  306.         }
  307.         
  308.         
  309.         if(httpsTrustStoreOCSPPolicy!=null && !"".equals(httpsTrustStoreOCSPPolicy)) {
  310.             prop = new org.openspcoop2.core.registry.Property();
  311.             prop.setNome(CostantiDB.CONNETTORE_HTTPS_TRUST_STORE_OCSP_POLICY);
  312.             prop.setValore(httpsTrustStoreOCSPPolicy);
  313.             connettore.addProperty(prop);
  314.             
  315.             if(!httpsTrustVerifyCert &&
  316.                 httpsTrustStoreCRLs!=null && !"".equals(httpsTrustStoreCRLs)) {
  317.                 prop = new org.openspcoop2.core.registry.Property();
  318.                 prop.setNome(CostantiDB.CONNETTORE_HTTPS_TRUST_STORE_CRLS);
  319.                 prop.setValore(httpsTrustStoreCRLs);
  320.                 connettore.addProperty(prop);
  321.             }
  322.         }
  323.         
  324.         if (httpsstato) {

  326.             prop = new org.openspcoop2.core.registry.Property();
  327.             prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_MANAGEMENT_ALGORITM);
  328.             if (httpsalgoritmokey == null || "".equals(httpsalgoritmokey))
  329.                 prop.setValore(javax.net.ssl.KeyManagerFactory.getDefaultAlgorithm());
  330.             else
  331.                 prop.setValore(httpsalgoritmokey);
  332.             connettore.addProperty(prop);


  335.             if (ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE_DEFAULT.equals(httpskeystore)) {
  336.                 if(httpspwdprivatekeytrust!=null && !"".equals(httpspwdprivatekeytrust)) {
  337.                     prop = new org.openspcoop2.core.registry.Property();
  338.                     prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_PASSWORD);
  339.                     prop.setValore(httpspwdprivatekeytrust);
  340.                     connettore.addProperty(prop);
  341.                 }

  343.                 prop = new org.openspcoop2.core.registry.Property();
  344.                 prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_LOCATION);
  345.                 prop.setValore(httpspath);
  346.                 connettore.addProperty(prop);

  348.                 prop = new org.openspcoop2.core.registry.Property();
  349.                 prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_TYPE);
  350.                 prop.setValore(httpstipo);
  351.                 connettore.addProperty(prop);

  353.                 if(httpspwd!=null && !"".equals(httpspwd)) {
  354.                     prop = new org.openspcoop2.core.registry.Property();
  355.                     prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_PASSWORD);
  356.                     prop.setValore(httpspwd);
  357.                     connettore.addProperty(prop);
  358.                 }

  360.             } else {
  361.                 prop = new org.openspcoop2.core.registry.Property();
  362.                 prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_LOCATION);
  363.                 prop.setValore(httpspathkey);
  364.                 connettore.addProperty(prop);

  366.                 prop = new org.openspcoop2.core.registry.Property();
  367.                 prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_TYPE);
  368.                 prop.setValore(httpstipokey);
  369.                 connettore.addProperty(prop);

  371.                 if(httpspwdkey!=null && !"".equals(httpspwdkey)) {
  372.                     prop = new org.openspcoop2.core.registry.Property();
  373.                     prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_PASSWORD);
  374.                     prop.setValore(httpspwdkey);
  375.                     connettore.addProperty(prop);
  376.                 }

  378.                 if(httpspwdprivatekey!=null && !"".equals(httpspwdprivatekey)) {
  379.                     prop = new org.openspcoop2.core.registry.Property();
  380.                     prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_PASSWORD);
  381.                     prop.setValore(httpspwdprivatekey);
  382.                     connettore.addProperty(prop);
  383.                 }

  385.             }
  386.             
  387.             if(httpsKeyAlias!=null && !"".equals(httpsKeyAlias)) {
  388.                 prop = new org.openspcoop2.core.registry.Property();
  389.                 prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_ALIAS);
  390.                 prop.setValore(httpsKeyAlias);
  391.                 connettore.addProperty(prop);
  392.             }
  393.             
  394.             if(httpsKeyStoreBYOKPolicy!=null && !"".equals(httpsKeyStoreBYOKPolicy)) {
  395.                 prop = new org.openspcoop2.core.registry.Property();
  396.                 prop.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_BYOK_POLICY);
  397.                 prop.setValore(httpsKeyStoreBYOKPolicy);
  398.                 connettore.addProperty(prop);
  399.             }
  400.         }
  401.     }
  402.     
  403.     public static void addHTTPSDati(List<DataElement> dati,
  404.             String httpsurl, String httpstipologia, boolean httpshostverify,
  405.             boolean httpsTrustVerifyCert, String httpspath, String httpstipo, String httpspwd,
  406.             String httpsalgoritmo, boolean httpsstato, String httpskeystore,
  407.             String httpspwdprivatekeytrust, String httpspathkey,
  408.             String httpstipokey, String httpspwdkey,
  409.             String httpspwdprivatekey, String httpsalgoritmokey, 
  410.             String httpsKeyAlias, String httpsTrustStoreCRLs, String httpsTrustStoreOCSPPolicy, String httpsKeyStoreBYOKPolicy,
  411.             String stato,
  412.             ControlStationCore core,ConsoleHelper consoleHelper, int pageSize, boolean addUrlParameter,
  413.             String prefix, boolean forceHttpsClient,
  414.             boolean modi, boolean fruizione, boolean forceNoSec,
  415.             boolean postBackViaPost) throws UtilsException {
  416.         
  417.         // default
  418.         if(httpsalgoritmo==null || "".equals(httpsalgoritmo)){
  419.             httpsalgoritmo = TrustManagerFactory.getDefaultAlgorithm();
  420.         }
  421.         if(httpsalgoritmokey==null || "".equals(httpsalgoritmokey)){
  422.             httpsalgoritmokey = KeyManagerFactory.getDefaultAlgorithm();
  423.         }
  424.         if(httpstipologia==null || "".equals(httpstipologia)){
  425.             httpstipologia = ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_TYPE;
  426.         }
  427.         
  428.         if(addUrlParameter){
  429.             DataElement de = new DataElement();
  430.             de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_URL);
  431.             de.setValue(httpsurl);
  432.             if(!consoleHelper.isShowGestioneWorkflowStatoDocumenti() || !StatiAccordo.finale.toString().equals(stato)){
  433.                 de.setType(DataElementType.TEXT_EDIT);
  434.                 de.setRequired(true);   
  435.                 
  436.                 DataElementInfo dInfoPatternFileName = new DataElementInfo(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_URL);
  437.                 dInfoPatternFileName.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_INFO_TRASPORTO);
  438.                 dInfoPatternFileName.setListBody(DynamicHelperCostanti.getLABEL_CONFIGURAZIONE_INFO_CONNETTORE_VALORI(modi, fruizione, forceNoSec));
  439.                 de.setInfo(dInfoPatternFileName);
  440.             }else{
  441.                 de.setType(DataElementType.TEXT);
  442.             }
  443.             de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_URL);
  444.             de.setSize(pageSize);
  445.             dati.add(de);
  446.         }

  448.         if(prefix==null){
  449.             prefix = "";
  450.         }
  451.         
  452.         DataElement de = new DataElement();
  453.         de.setLabel(prefix+ConnettoriCostanti.LABEL_CONNETTORE_AUTENTICAZIONE);
  454.         de.setType(DataElementType.TITLE);
  455.         dati.add(de);

  457.         de = new DataElement();
  458.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_SSL_TYPE);
  459.         de.setType(DataElementType.SELECT);
  460.         List<String> tipologie = null;
  461.         try{
  462.             tipologie = SSLUtilities.getSSLSupportedProtocols();
  463.         }catch(Exception e){
  464.             ControlStationCore.logError(e.getMessage(), e);
  465.             tipologie = SSLUtilities.getAllSslProtocol();
  466.         }
  467.         if(httpstipologia!=null && !"".equals(httpstipologia) && 
  468.                 !tipologie.contains(httpstipologia)){
  469.             tipologie.add(httpstipologia); // per retrocompatibilità delle configurazioni SSL e TLS
  470.         }
  471.         de.setValues(tipologie);
  472.         de.setSelected(httpstipologia);
  473.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_SSL_TYPE);
  474.         dati.add(de);

  476.         de = new DataElement();
  477.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_HOST_VERIFY);
  478.         de.setValue(httpshostverify ? Costanti.CHECK_BOX_ENABLED : "");
  479.         de.setSelected(httpshostverify);
  480.         de.setType(DataElementType.CHECKBOX);
  481.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_HOST_VERIFY);
  482.         dati.add(de);

  484.         de = new DataElement();
  485.         de.setLabel(prefix+ConnettoriCostanti.LABEL_CONNETTORE_AUTENTICAZIONE_SERVER);
  486.         de.setType(DataElementType.SUBTITLE);
  487.         dati.add(de);

  489.         de = new DataElement();
  490.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_TRUST_VERIFY_CERTS);
  491.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_VERIFY_CERTS);
  492.         de.setValue(httpsTrustVerifyCert ? Costanti.CHECK_BOX_ENABLED : "");
  493.         de.setSelected(httpsTrustVerifyCert);
  494.         de.setType(DataElementType.CHECKBOX);
  495.         if(postBackViaPost) {
  496.             de.setPostBack_viaPOST(true);
  497.         }
  498.         else {
  499.             de.setPostBack(true);
  500.         }
  501.         dati.add(de);
  502.         
  503.         boolean truststoreHsm = false;
  504.         String httpstipoDefault = null;
  505.         de = new DataElement();
  506.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_TYPE);
  507.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_TYPE);
  508.         if(httpsTrustVerifyCert) {
  509.             de.setType(DataElementType.SELECT);
  510.             if(core.isConnettoriAllTypesEnabled()) {
  511.                 de.setValues(ConnettoriCostanti.TIPOLOGIE_KEYSTORE_OLD);
  512.             }
  513.             else {
  514.                 List<String> values = ConnettoriCostanti.getTIPOLOGIE_KEYSTORE(true, false);
  515.                 List<String> labels = ConnettoriCostanti.getTIPOLOGIE_KEYSTORE(true, true);
  516.                 // per retrocompatibilita verifico che esista ancora nelle nuove, altrimenti lo aggiungo
  517.                 if(httpstipo!=null && !"".equals(httpstipo)) {
  518.                     boolean exists = false;
  519.                     for (String v : values) {
  520.                         if(httpstipo.equalsIgnoreCase(v)) {
  521.                             exists = true;
  522.                         }
  523.                     }
  524.                     if(!exists) {
  525.                         values.add(httpstipo);
  526.                     }
  527.                 }
  528.                 de.setValues(values);
  529.                 de.setLabels(labels);
  530.                 if(ConnettoriCostanti.existsTIPOLOGIE_KEYSTORE_HSM(true)) {
  531.                     if(postBackViaPost) {
  532.                         de.setPostBack_viaPOST(true);
  533.                     }
  534.                     else {
  535.                         de.setPostBack(true);
  536.                     }
  537.                 }
  538.             }
  539.             if(httpstipo!=null) {
  540.                 de.setSelected(httpstipo);
  541.                 truststoreHsm = HSMUtils.isKeystoreHSM(httpstipo);
  542.             }
  543.         }
  544.         else {
  545.             de.setType(DataElementType.HIDDEN);
  546.         }
  547.         if( (httpstipo==null || "".equals(httpstipo)) 
  548.                 && de.getValues()!=null && de.getValues().length>0) {
  549.                 httpstipoDefault = de.getValues()[0];
  550.         }
  551.         dati.add(de);

  553.         de = new DataElement();
  554.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_LOCATION);
  555.         de.setValue(httpspath);
  556.         if(httpsTrustVerifyCert) {
  557.             if(truststoreHsm) {
  558.                 de.setValue(ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_PATH_HSM_PREFIX+httpstipo);
  559.                 de.setType(DataElementType.HIDDEN);
  560.             }
  561.             else {
  562.                 if(!consoleHelper.isShowGestioneWorkflowStatoDocumenti() || !StatiAccordo.finale.toString().equals(stato)){
  563.                     de.setType(DataElementType.TEXT_AREA);
  564.                     de.setRequired(true);   
  565.                 }else{
  566.                     de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  567.                 }
  568.                 de.setRows(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_LOCATION_SIZE);
  569.                 de.setSize(pageSize);
  570.             }
  571.         }
  572.         else {
  573.             de.setType(DataElementType.HIDDEN);
  574.         }
  575.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_LOCATION);
  576.         dati.add(de);
  577.         
  578.         de = new DataElement();
  579.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_PASSWORD);
  580.         if(httpsTrustVerifyCert) {
  581.             if(truststoreHsm) {
  582.                 de.setValue(ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_HSM_STORE_PASSWORD_UNDEFINED);
  583.                 de.setType(DataElementType.HIDDEN);
  584.             }
  585.             else if(!consoleHelper.isShowGestioneWorkflowStatoDocumenti() || !StatiAccordo.finale.toString().equals(stato)){
  586.                 de.setRequired(isStorePasswordRequired(httpstipo, httpstipoDefault, false, false, core));
  587.                 core.getLockUtilities().lock(de, httpspwd);
  588.             }else{
  589.                 core.getLockUtilities().lockReadOnly(de, httpspwd);
  590.             }
  591.             de.setSize(pageSize);
  592.         }
  593.         else {
  594.             core.getLockUtilities().lockHidden(de, httpspwd);
  595.         }
  596.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_PASSWORD);
  597.         dati.add(de);

  599.         OCSPProvider ocspProvider = new OCSPProvider();
  600.         boolean ocspEnabled = ocspProvider.isOcspEnabled();
  601.         List<String> ocspTypes = ocspProvider.getValues();
  602.         List<String> ocspLabels = ocspProvider.getLabels();
  603.                 
  604.         boolean crlWithOCSPEnabledTrustAllHttpsServer = 
  605.                 ocspEnabled &&
  606.                 core.isOCSPPolicyChoiceConnettoreHTTPSVerificaServerDisabilitata() &&
  607.                 httpsTrustStoreOCSPPolicy!=null &&
  608.                 !"".equals(httpsTrustStoreOCSPPolicy);
  609.                 
  610.         de = new DataElement();
  611.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_OCSP_POLICY);
  612.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_OCSP_POLICY);
  613.         if(ocspEnabled && (httpsTrustVerifyCert || core.isOCSPPolicyChoiceConnettoreHTTPSVerificaServerDisabilitata())) {
  614.             if(!consoleHelper.isShowGestioneWorkflowStatoDocumenti() || !StatiAccordo.finale.toString().equals(stato)){
  615.                 de.setType(DataElementType.SELECT);
  616.                 de.setValues(ocspTypes);
  617.                 de.setLabels(ocspLabels);
  618.                 if(postBackViaPost) {
  619.                     de.setPostBack_viaPOST(core.isOCSPPolicyChoiceConnettoreHTTPSVerificaServerDisabilitata());
  620.                 }
  621.                 else {
  622.                     de.setPostBack(core.isOCSPPolicyChoiceConnettoreHTTPSVerificaServerDisabilitata());
  623.                 }
  624.                 if(httpsTrustStoreOCSPPolicy==null) {
  625.                     httpsTrustStoreOCSPPolicy = "";
  626.                 }   
  627.                 de.setSelected(httpsTrustStoreOCSPPolicy);
  628.             }else{
  629.                 de.setType(DataElementType.HIDDEN);
  630.                 
  631.                 if(httpsTrustStoreOCSPPolicy!=null &&
  632.                         !"".equals(httpsTrustStoreOCSPPolicy)){
  633.                     
  634.                     String label = null;
  635.                     for (int i = 0; i < ocspTypes.size(); i++) {
  636.                         String type = ocspTypes.get(i);
  637.                         if(type!=null && type.equals(httpsTrustStoreOCSPPolicy)) {
  638.                             label = ocspLabels.get(i);
  639.                         }
  640.                     }
  641.                     if(label!=null) {
  642.                         DataElement deLABEL = new DataElement();
  643.                         de.setType(DataElementType.TEXT);
  644.                         deLABEL.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_OCSP_POLICY);
  645.                         deLABEL.setValue(label);
  646.                         deLABEL.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_OCSP_POLICY+CostantiControlStation.PARAMETRO_SUFFIX_LABEL);
  647.                         dati.add(deLABEL);
  648.                     }
  649.                 }
  650.             }
  651.             de.setSize(pageSize);
  652.         }
  653.         else {
  654.             de.setType(DataElementType.HIDDEN);
  655.         }
  656.         de.setValue(httpsTrustStoreOCSPPolicy);
  657.         dati.add(de);
  658.         
  659.         de = new DataElement();
  660.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_CRL);
  661.         de.setValue(httpsTrustStoreCRLs);
  662.         if(httpsTrustVerifyCert || crlWithOCSPEnabledTrustAllHttpsServer) {
  663.             de.setNote(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_CRL_NOTE);
  664.             if(!consoleHelper.isShowGestioneWorkflowStatoDocumenti() || !StatiAccordo.finale.toString().equals(stato)){
  665.                 de.setType(DataElementType.TEXT_AREA);  
  666.             }else{
  667.                 de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  668.             }
  669.             de.setRows(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_CRL_SIZE);
  670.             de.setSize(pageSize);
  671.         }
  672.         else {
  673.             de.setType(DataElementType.HIDDEN);
  674.         }
  675.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_CRL);
  676.         dati.add(de);
  677.         
  678.         de = new DataElement();
  679.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_TRUST_MANAGEMENT_ALGORITM);
  680.         de.setValue(httpsalgoritmo);
  681.         if(httpsTrustVerifyCert) {
  682.             if(!consoleHelper.isModalitaStandard()) {
  683.                 if(!consoleHelper.isShowGestioneWorkflowStatoDocumenti() || !StatiAccordo.finale.toString().equals(stato)){
  684.                     de.setType(DataElementType.TEXT_EDIT);
  685.                     de.setRequired(true);   
  686.                 }else{
  687.                     de.setType(DataElementType.TEXT);
  688.                 }
  689.                 de.setSize(pageSize);
  690.             }
  691.             else {
  692.                 de.setType(DataElementType.HIDDEN);
  693.             }
  694.         }
  695.         else {
  696.             de.setType(DataElementType.HIDDEN);
  697.         }
  698.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_MANAGEMENT_ALGORITM);
  699.         dati.add(de);

  701.         de = new DataElement();
  702.         de.setLabel(prefix+ConnettoriCostanti.LABEL_CONNETTORE_AUTENTICAZIONE_CLIENT);
  703.         de.setType(DataElementType.SUBTITLE);
  704.         dati.add(de);

  706.         de = new DataElement();
  707.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_STATO);
  708.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_STATO);
  709.         if(forceHttpsClient) {
  710.             httpsstato = true;
  711.             de.setValue(Costanti.CHECK_BOX_ENABLED);
  712.             de.setType(DataElementType.HIDDEN);
  713.         }
  714.         else {
  715.             de.setValue(httpsstato ? Costanti.CHECK_BOX_ENABLED : "");
  716.             de.setSelected(httpsstato);
  717.             de.setType(DataElementType.CHECKBOX);
  718.             if(postBackViaPost) {
  719.                 de.setPostBack_viaPOST(true);
  720.             }
  721.             else {
  722.                 de.setPostBack(true);
  723.             }
  724.         }
  725.         dati.add(de);


  728.         de = new DataElement();
  729.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE);
  730.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE);
  731.         if (httpsstato) {
  732.             if(httpsTrustVerifyCert) {
  733.                 de.setType(DataElementType.SELECT);
  734.                 de.setValues(ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODES);
  735.                 de.setLabels(ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_LABEL_MODES);
  736.                 de.setSelected(httpskeystore);
  737.                 if(postBackViaPost) {
  738.                     de.setPostBack_viaPOST(true);
  739.                 }
  740.                 else {
  741.                     de.setPostBack(true);
  742.                 }
  743.             }
  744.             else {
  745.                 de.setType(DataElementType.HIDDEN);
  746.                 httpskeystore = ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE_RIDEFINISCI;
  747.                 de.setValue(ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE_RIDEFINISCI);
  748.             }
  749.         } else {
  750.             de.setType(DataElementType.HIDDEN);
  751.             de.setValue("");
  752.         }
  753.         dati.add(de);

  755.         de = new DataElement();
  756.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_PASSWORD_PRIVATE_KEY_STORE);
  757.         if (httpsstato &&
  758.                 (httpskeystore == null || "".equals(httpskeystore) || httpskeystore.equals(ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE_DEFAULT))){
  759.             if(!consoleHelper.isShowGestioneWorkflowStatoDocumenti() || !StatiAccordo.finale.toString().equals(stato)){
  760.                 de.setRequired(isStorePasswordRequired(httpstipo, httpstipoDefault, true, true, core));
  761.                 core.getLockUtilities().lock(de, httpspwdprivatekeytrust);
  762.             }else{
  763.                 core.getLockUtilities().lockReadOnly(de, httpspwdprivatekeytrust);
  764.             }
  765.         }else {
  766.             core.getLockUtilities().lockHidden(de, httpspwdprivatekeytrust);
  767.         }
  768.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_PASSWORD_PRIVATE_KEY_STORE);
  769.         de.setSize(pageSize);
  770.         dati.add(de);

  772.         boolean keystoreHsm = false;
  773.         de = new DataElement();
  774.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_TYPE);
  775.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_TYPE);
  776.         String httpstipokeyDefault = null;
  777.         if (httpsstato &&
  778.                 (httpskeystore != null && httpskeystore.equals(ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE_RIDEFINISCI))) {
  779.             de.setType(DataElementType.SELECT);
  780.             if(core.isConnettoriAllTypesEnabled()) {
  781.                 de.setValues(ConnettoriCostanti.TIPOLOGIE_KEYSTORE_OLD);
  782.             }
  783.             else {
  784.                 List<String> values = ConnettoriCostanti.getTIPOLOGIE_KEYSTORE(false, false);
  785.                 List<String> labels = ConnettoriCostanti.getTIPOLOGIE_KEYSTORE(false, true);
  786.                 // per retrocompatibilita verifico che esista ancora nelle nuove, altrimenti lo aggiungo
  787.                 if(httpstipokey!=null && !"".equals(httpstipokey)) {
  788.                     boolean exists = false;
  789.                     for (String v : values) {
  790.                         if(httpstipokey.equalsIgnoreCase(v)) {
  791.                             exists = true;
  792.                             break;
  793.                         }
  794.                     }
  795.                     if(!exists) {
  796.                         values.add(httpstipokey);
  797.                     }
  798.                 }
  799.                 de.setValues(values);
  800.                 de.setLabels(labels);
  801.                 if(ConnettoriCostanti.existsTIPOLOGIE_KEYSTORE_HSM(false)) {
  802.                     if(postBackViaPost) {
  803.                         de.setPostBack_viaPOST(true);
  804.                     }
  805.                     else {
  806.                         de.setPostBack(true);
  807.                     }
  808.                 }
  809.             }
  810.             if(httpstipokey!=null) {
  811.                 de.setSelected(httpstipokey);
  812.                 keystoreHsm = HSMUtils.isKeystoreHSM(httpstipokey);
  813.             }
  814.         } else {
  815.             de.setType(DataElementType.HIDDEN);
  816.             de.setValue("");
  817.         }
  818.         if( (httpstipokey==null || "".equals(httpstipokey)) 
  819.             && de.getValues()!=null && de.getValues().length>0) {
  820.             httpstipokeyDefault = de.getValues()[0];
  821.         }
  822.         dati.add(de);
  823.         
  824.         de = new DataElement();
  825.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_LOCATION);
  826.         de.setValue(httpspathkey);
  827.         if (httpsstato &&
  828.                 (httpskeystore != null && httpskeystore.equals(ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE_RIDEFINISCI))){
  829.             if(keystoreHsm) {
  830.                 de.setValue(ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_PATH_HSM_PREFIX+httpstipokey);
  831.                 de.setType(DataElementType.HIDDEN);
  832.             }
  833.             else {
  834.                 if(!consoleHelper.isShowGestioneWorkflowStatoDocumenti() || !StatiAccordo.finale.toString().equals(stato)){
  835.                     de.setType(DataElementType.TEXT_AREA);
  836.                     de.setRequired(true);   
  837.                 }else{
  838.                     de.setType(DataElementType.TEXT_AREA_NO_EDIT);
  839.                 }
  840.                 de.setRows(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_LOCATION_SIZE);
  841.             }
  842.         }else
  843.             de.setType(DataElementType.HIDDEN);
  844.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_LOCATION);
  845.         de.setSize(pageSize);
  846.         dati.add(de);

  848.         de = new DataElement();
  849.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_PASSWORD);
  850.         if (httpsstato &&
  851.                 (httpskeystore != null && httpskeystore.equals(ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE_RIDEFINISCI))){
  852.             if(keystoreHsm) {
  853.                 de.setValue(ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_HSM_STORE_PASSWORD_UNDEFINED);
  854.                 de.setType(DataElementType.HIDDEN);
  855.             }
  856.             else if(!consoleHelper.isShowGestioneWorkflowStatoDocumenti() || !StatiAccordo.finale.toString().equals(stato)){
  857.                 de.setRequired(isStorePasswordRequired(httpstipokey, httpstipokeyDefault, true, false, core));
  858.                 core.getLockUtilities().lock(de, httpspwdkey);
  859.             }else{
  860.                 core.getLockUtilities().lockReadOnly(de, httpspwdkey);
  861.             }
  862.         }else {
  863.             core.getLockUtilities().lockHidden(de, httpspwdkey);
  864.         }
  865.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_PASSWORD);
  866.         de.setSize(pageSize);
  867.         dati.add(de);

  869.         de = new DataElement();
  870.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_PASSWORD_PRIVATE_KEY_KEYSTORE);
  871.         if (httpsstato &&
  872.                 (httpskeystore != null && httpskeystore.equals(ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE_RIDEFINISCI))){
  873.             if(keystoreHsm && !ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_HSM_CONFIGURABLE_KEY_PASSWORD) {
  874.                 de.setValue(ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_HSM_PRIVATE_KEY_PASSWORD_UNDEFINED);
  875.                 de.setType(DataElementType.HIDDEN);
  876.             }
  877.             else if(!consoleHelper.isShowGestioneWorkflowStatoDocumenti() || !StatiAccordo.finale.toString().equals(stato)){
  878.                 de.setRequired(isStorePasswordRequired(httpstipokey, httpstipokeyDefault, true, true, core));
  879.                 core.getLockUtilities().lock(de, httpspwdprivatekey);
  880.             }else{
  881.                 core.getLockUtilities().lockReadOnly(de, httpspwdprivatekey);
  882.             }
  883.         }else {
  884.             core.getLockUtilities().lockHidden(de, httpspwdprivatekey);
  885.         }
  886.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_PASSWORD_PRIVATE_KEY_KEYSTORE);
  887.         de.setSize(pageSize);
  888.         dati.add(de);

  890.         de = new DataElement();
  891.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_ALIAS_PRIVATE_KEY_KEYSTORE);
  892.         de.setValue(httpsKeyAlias);
  893.         if (httpsstato){
  894.             if(!consoleHelper.isShowGestioneWorkflowStatoDocumenti() || !StatiAccordo.finale.toString().equals(stato)){
  895.                 de.setType(DataElementType.TEXT_EDIT);  
  896.             }else{
  897.                 de.setType(DataElementType.TEXT);
  898.             }
  899.         }else
  900.             de.setType(DataElementType.HIDDEN);
  901.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_ALIAS_PRIVATE_KEY_KEYSTORE);
  902.         de.setSize(pageSize);
  903.         dati.add(de);
  904.         
  905.         de = new DataElement();
  906.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_KEY_MANAGEMENT_ALGORITM);
  907.         de.setValue(httpsalgoritmokey);
  908.         if (httpsstato && !consoleHelper.isModalitaStandard()){
  909.             if(!consoleHelper.isShowGestioneWorkflowStatoDocumenti() || !StatiAccordo.finale.toString().equals(stato)){
  910.                 de.setType(DataElementType.TEXT_EDIT);
  911.                 de.setRequired(true);   
  912.             }else{
  913.                 de.setType(DataElementType.TEXT);
  914.             }
  915.         }else
  916.             de.setType(DataElementType.HIDDEN);
  917.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_MANAGEMENT_ALGORITM);
  918.         de.setSize(pageSize);
  919.         dati.add(de);
  920.         
  921.         
  922.         
  923.         
  924.         
  925.         BYOKProvider byokProvider = BYOKProvider.getUnwrapInstance();
  926.         boolean byokEnabled = byokProvider.isUnwrapByokKeystoreEnabled();
  927.         List<String> byokTypes = byokProvider.getValues();
  928.         List<String> byokLabels = byokProvider.getLabels();
  929.         
  930.         de = new DataElement();
  931.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_BYOK_POLICY);
  932.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_BYOK_POLICY);
  933.         if(byokEnabled && httpsstato && !keystoreHsm) {
  934.             if(!consoleHelper.isShowGestioneWorkflowStatoDocumenti() || !StatiAccordo.finale.toString().equals(stato)){
  935.                 de.setType(DataElementType.SELECT);
  936.                 de.setValues(byokTypes);
  937.                 de.setLabels(byokLabels);
  938.                 if(postBackViaPost) {
  939.                     de.setPostBack_viaPOST(true);
  940.                 }
  941.                 else {
  942.                     de.setPostBack(true);
  943.                 }
  944.                 if(httpsKeyStoreBYOKPolicy==null) {
  945.                     httpsKeyStoreBYOKPolicy = "";
  946.                 }   
  947.                 de.setSelected(httpsKeyStoreBYOKPolicy);
  948.             }else{
  949.                 de.setType(DataElementType.HIDDEN);
  950.                 
  951.                 if(httpsKeyStoreBYOKPolicy!=null &&
  952.                         !"".equals(httpsKeyStoreBYOKPolicy)){
  953.                     
  954.                     String label = null;
  955.                     for (int i = 0; i < byokTypes.size(); i++) {
  956.                         String type = byokTypes.get(i);
  957.                         if(type!=null && type.equals(httpsKeyStoreBYOKPolicy)) {
  958.                             label = byokLabels.get(i);
  959.                         }
  960.                     }
  961.                     if(label!=null) {
  962.                         DataElement deLABEL = new DataElement();
  963.                         de.setType(DataElementType.TEXT);
  964.                         deLABEL.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_BYOK_POLICY);
  965.                         deLABEL.setValue(label);
  966.                         deLABEL.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_BYOK_POLICY+CostantiControlStation.PARAMETRO_SUFFIX_LABEL);
  967.                         dati.add(deLABEL);
  968.                     }
  969.                 }
  970.             }
  971.             de.setSize(pageSize);
  972.             de.setValue(httpsKeyStoreBYOKPolicy);
  973.         }
  974.         else {
  975.             de.setType(DataElementType.HIDDEN);
  976.         }
  977.         dati.add(de);
  978.     }
  979.     private static boolean isStorePasswordRequired(String httpstipo, String httpstipoDefault, boolean keystore, boolean key, ControlStationCore core) {
  980.         String check = httpstipo;
  981.         if(httpstipo==null || "".equals(httpstipo)) {
  982.             check = httpstipoDefault;
  983.         }
  984.         
  985.         if(KeystoreType.JKS.isType(check)) {
  986.             return isStoreJksPasswordRequired(keystore, key, core);
  987.         }
  988.         else if(KeystoreType.PKCS12.isType(check)) {
  989.             return isStorePkcs12PasswordRequired(keystore, key, core);
  990.         }
  991.         else {
  992.             return true;
  993.         }
  994.     }
  995.     private static boolean isStoreJksPasswordRequired(boolean keystore, boolean key,
  996.             ControlStationCore core) {
  997.         if(keystore) {
  998.             return key ? core.isKeystoreJksKeyPasswordRequired() : core.isKeystoreJksPasswordRequired();
  999.         }
  1000.         else {
  1001.             return core.isTruststoreJksPasswordRequired();
  1002.         }
  1003.     }
  1004.     private static boolean isStorePkcs12PasswordRequired(boolean keystore, boolean key,
  1005.             ControlStationCore core) {
  1006.         if(keystore) {
  1007.             return key ? core.isKeystorePkcs12KeyPasswordRequired() : core.isKeystorePkcs12PasswordRequired();
  1008.         }
  1009.         else {
  1010.             return core.isTruststorePkcs12PasswordRequired();
  1011.         }
  1012.     }
  1013.     
  1014.     public static void addHTTPSDatiAsHidden(List<DataElement> dati,
  1015.             String httpsurl, String httpstipologia, boolean httpshostverify,
  1016.             boolean httpsTrustVerifyCert, String httpspath, String httpstipo, String httpspwd,
  1017.             String httpsalgoritmo, boolean httpsstato, String httpskeystore,
  1018.             String httpspwdprivatekeytrust, String httpspathkey,
  1019.             String httpstipokey, String httpspwdkey,
  1020.             String httpspwdprivatekey, String httpsalgoritmokey,
  1021.             String httpsKeyAlias, String httpsTrustStoreCRLs, String httpsTrustStoreOCSPPolicy, String httpsKeyStoreBYOKPolicy,
  1022.             String stato,
  1023.             ControlStationCore core,int pageSize){
  1024.         
  1025.         if(stato!=null && core!=null) {
  1026.             // nop
  1027.         }
  1028.         
  1029.         DataElement de = new DataElement();
  1030.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_URL);
  1031.         de.setValue(httpsurl);
  1032.         de.setType(DataElementType.HIDDEN);
  1033.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_URL);
  1034.         de.setSize(pageSize);
  1035.         dati.add(de);


  1038.         de = new DataElement();
  1039.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_SSL_TYPE);
  1040.         de.setType(DataElementType.HIDDEN);
  1041.         de.setValue(httpstipologia);
  1042.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_SSL_TYPE);
  1043.         dati.add(de);

  1045.         de = new DataElement();
  1046.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_HOST_VERIFY);
  1047.         de.setValue(httpshostverify ? Costanti.CHECK_BOX_ENABLED : "");
  1048.         de.setType(DataElementType.HIDDEN);
  1049.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_HOST_VERIFY);
  1050.         dati.add(de);

  1052.         de = new DataElement();
  1053.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_TRUST_VERIFY_CERTS);
  1054.         de.setValue(httpsTrustVerifyCert ? Costanti.CHECK_BOX_ENABLED : "");
  1055.         de.setType(DataElementType.HIDDEN);
  1056.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_VERIFY_CERTS);
  1057.         de.setSize(pageSize);
  1058.         dati.add(de);
  1059.         
  1060.         de = new DataElement();
  1061.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_LOCATION);
  1062.         de.setValue(httpspath);
  1063.         de.setType(DataElementType.HIDDEN);
  1064.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_LOCATION);
  1065.         de.setSize(pageSize);
  1066.         dati.add(de);

  1068.         de = new DataElement();
  1069.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_TYPE);
  1070.         de.setType(DataElementType.HIDDEN);
  1071.         de.setValue(httpstipo);
  1072.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_TYPE);
  1073.         dati.add(de);

  1075.         de = new DataElement();
  1076.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_PASSWORD);
  1077.         de.setValue(httpspwd);
  1078.         de.setType(DataElementType.HIDDEN);
  1079.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_PASSWORD);
  1080.         de.setSize(pageSize);
  1081.         dati.add(de);

  1083.         de = new DataElement();
  1084.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_CRL);
  1085.         de.setValue(httpsTrustStoreCRLs);
  1086.         de.setType(DataElementType.HIDDEN);
  1087.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_CRL);
  1088.         de.setSize(pageSize);
  1089.         dati.add(de);
  1090.         
  1091.         de = new DataElement();
  1092.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_OCSP_POLICY);
  1093.         de.setValue(httpsTrustStoreOCSPPolicy);
  1094.         de.setType(DataElementType.HIDDEN);
  1095.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_STORE_OCSP_POLICY);
  1096.         de.setSize(pageSize);
  1097.         dati.add(de);
  1098.         
  1099.         de = new DataElement();
  1100.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_TRUST_MANAGEMENT_ALGORITM);
  1101.         de.setValue(httpsalgoritmo);
  1102.         de.setType(DataElementType.HIDDEN);
  1103.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_TRUST_MANAGEMENT_ALGORITM);
  1104.         de.setSize(pageSize);
  1105.         dati.add(de);

  1107.         de = new DataElement();
  1108.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_STATO);
  1109.         de.setValue(httpsstato ? Costanti.CHECK_BOX_ENABLED : "");
  1110.         de.setType(DataElementType.HIDDEN);
  1111.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_STATO);
  1112.         dati.add(de);


  1115.         de = new DataElement();
  1116.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE);
  1117.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE);
  1118.         de.setType(DataElementType.HIDDEN); 
  1119.         if (httpsstato) {
  1120.             de.setValue(httpskeystore);
  1121.         } else {
  1122.             de.setValue("");
  1123.         }
  1124.         dati.add(de);

  1126.         de = new DataElement();
  1127.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_PASSWORD_PRIVATE_KEY_STORE);
  1128.         de.setValue(httpspwdprivatekeytrust);
  1129.         de.setType(DataElementType.HIDDEN);
  1130.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_PASSWORD_PRIVATE_KEY_STORE);
  1131.         de.setSize(pageSize);
  1132.         dati.add(de);

  1134.         de = new DataElement();
  1135.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_LOCATION);
  1136.         de.setValue(httpspathkey);
  1137.         de.setType(DataElementType.HIDDEN);
  1138.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_LOCATION);
  1139.         de.setSize(pageSize);
  1140.         dati.add(de);

  1142.         de = new DataElement();
  1143.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_TYPE);
  1144.         if (httpsstato &&
  1145.                 (httpskeystore != null && httpskeystore.equals(ConnettoriCostanti.DEFAULT_CONNETTORE_HTTPS_KEYSTORE_CLIENT_AUTH_MODE_RIDEFINISCI))) {
  1146.             de.setType(DataElementType.HIDDEN);
  1147.             de.setValue(httpstipokey);
  1148.         } else {
  1149.             de.setType(DataElementType.HIDDEN);
  1150.             de.setValue("");
  1151.         }
  1152.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_TYPE);
  1153.         dati.add(de);

  1155.         de = new DataElement();
  1156.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_PASSWORD);
  1157.         de.setValue(httpspwdkey);
  1158.         de.setType(DataElementType.HIDDEN);
  1159.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_PASSWORD);
  1160.         de.setSize(pageSize);
  1161.         dati.add(de);

  1163.         de = new DataElement();
  1164.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_PASSWORD_PRIVATE_KEY_KEYSTORE);
  1165.         de.setValue(httpspwdprivatekey);
  1166.         de.setType(DataElementType.HIDDEN);
  1167.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_PASSWORD_PRIVATE_KEY_KEYSTORE);
  1168.         de.setSize(pageSize);
  1169.         dati.add(de);
  1170.         
  1171.         de = new DataElement();
  1172.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_ALIAS_PRIVATE_KEY_KEYSTORE);
  1173.         de.setValue(httpsKeyAlias);
  1174.         de.setType(DataElementType.HIDDEN);
  1175.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_ALIAS_PRIVATE_KEY_KEYSTORE);
  1176.         de.setSize(pageSize);
  1177.         dati.add(de);

  1179.         de = new DataElement();
  1180.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_KEY_MANAGEMENT_ALGORITM);
  1181.         de.setValue(httpsalgoritmokey);
  1182.         de.setType(DataElementType.HIDDEN);
  1183.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_MANAGEMENT_ALGORITM);
  1184.         de.setSize(pageSize);
  1185.         dati.add(de);
  1186.                 
  1187.         de = new DataElement();
  1188.         de.setLabel(ConnettoriCostanti.LABEL_PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_BYOK_POLICY);
  1189.         de.setValue(httpsKeyStoreBYOKPolicy);
  1190.         de.setType(DataElementType.HIDDEN);
  1191.         de.setName(ConnettoriCostanti.PARAMETRO_CONNETTORE_HTTPS_KEY_STORE_BYOK_POLICY);
  1192.         de.setSize(pageSize);
  1193.         dati.add(de);
  1194.         
  1195.     }
  1196.     
  1197. }
Created with JaCoCo 0.8.8.202204050719