SSLUtilities.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.utils.transport.http;

  23. import java.io.ByteArrayInputStream;
  24. import java.io.File;
  25. import java.io.FileInputStream;
  26. import java.io.InputStream;
  27. import java.io.StringWriter;
  28. import java.lang.reflect.Method;
  29. import java.security.Key;
  30. import java.security.KeyStore;
  31. import java.security.Provider;
  32. import java.security.Provider.Service;
  33. import java.security.Security;
  34. import java.security.cert.CertStore;
  35. import java.security.cert.Certificate;
  36. import java.security.cert.CertificateFactory;
  37. import java.security.cert.CollectionCertStoreParameters;
  38. import java.security.cert.PKIXBuilderParameters;
  39. import java.security.cert.X509CRL;
  40. import java.security.cert.X509CertSelector;
  41. import java.util.ArrayList;
  42. import java.util.Enumeration;
  43. import java.util.List;

  45. import javax.net.ssl.CertPathTrustManagerParameters;
  46. import javax.net.ssl.HostnameVerifier;
  47. import javax.net.ssl.KeyManager;
  48. import javax.net.ssl.KeyManagerFactory;
  49. import javax.net.ssl.SSLContext;
  50. import javax.net.ssl.SSLSocket;
  51. import javax.net.ssl.SSLSocketFactory;
  52. import javax.net.ssl.TrustManager;
  53. import javax.net.ssl.TrustManagerFactory;
  54. import javax.net.ssl.X509KeyManager;
  55. import javax.net.ssl.X509TrustManager;
  56. import javax.servlet.http.HttpServletRequest;

  58. import org.bouncycastle.openssl.jcajce.JcaPEMWriter;
  59. import org.openspcoop2.utils.Utilities;
  60. import org.openspcoop2.utils.UtilsException;
  61. import org.openspcoop2.utils.certificate.KeystoreType;
  62. import org.openspcoop2.utils.certificate.KeystoreUtils;
  63. import org.openspcoop2.utils.certificate.hsm.HSMManager;
  64. import org.openspcoop2.utils.date.DateManager;
  65. import org.openspcoop2.utils.random.RandomGenerator;
  66. import org.openspcoop2.utils.resources.Loader;
  67. import org.slf4j.Logger;

  69. /**
  70.  * SSLUtilities
  71.  *
  72.  * @author Poli Andrea (apoli@link.it)
  73.  * @author $Author$
  74.  * @version $Rev$, $Date$
  75.  */
  76. public class SSLUtilities {
  77.     
  78.     private SSLUtilities() {}
  79.     
  80.     
  81.     private static String jvmHttpsClientCertificateConfigurated = null;
  82.     private static synchronized void initJvmHttpsClientCertificateConfigurated() {
  83.         if(jvmHttpsClientCertificateConfigurated==null) {
  84.             jvmHttpsClientCertificateConfigurated = System.getProperty("javax.net.ssl.keyStore");
  85.         }
  86.     }
  87.     public static boolean isJvmHttpsClientCertificateConfigurated() {
  88.         if(jvmHttpsClientCertificateConfigurated==null) {
  89.             initJvmHttpsClientCertificateConfigurated();
  90.         }
  91.         return jvmHttpsClientCertificateConfigurated!=null;
  92.     }
  93.     public static String getJvmHttpsClientCertificateConfigurated() {
  94.         if(jvmHttpsClientCertificateConfigurated==null) {
  95.             initJvmHttpsClientCertificateConfigurated();
  96.         }
  97.         return jvmHttpsClientCertificateConfigurated;
  98.     }
  99.     
  100.     
  101.     public static List<String> getSSLEnabledProtocols(String sslType) throws UtilsException{
  102.         try{
  103.             List<String> p = new ArrayList<>();
  104.             SSLContext context = SSLContext.getInstance(sslType);
  105.             context.init(null,null,null);
  106.             SSLSocket socket = null;
  107.             try {
  108.                 socket = (SSLSocket)context.getSocketFactory().createSocket();
  109.                 String[] protocols = socket.getEnabledProtocols();
  110.                 for (int i = 0; i < protocols.length; i++) {
  111.                     p.add(protocols[i]);
  112.                 }
  113.             }finally {
  114.                 try {
  115.                     if(socket!=null) {
  116.                         socket.close();
  117.                     }
  118.                 }catch(Throwable t) {
  119.                     // ignore
  120.                 }
  121.             }
  122.             return p;
  123.         }catch(Exception e){
  124.             throw new UtilsException(e.getMessage(), e);
  125.         }
  126.     }
  127.     public static List<String> getSSLSupportedProtocols() throws UtilsException{
  128.         try{
  129.             List<String> p = new ArrayList<>();
  130.             SSLContext defaultContext = SSLContext.getDefault();
  131.             SSLSocket socket = null;
  132.             try {
  133.                 socket = (SSLSocket)defaultContext.getSocketFactory().createSocket();
  134.                 String[] protocols = socket.getSupportedProtocols();
  135.                 for (int i = 0; i < protocols.length; i++) {
  136.                     p.add(protocols[i]);
  137.                 }
  138.             }finally {
  139.                 try {
  140.                     if(socket!=null) {
  141.                         socket.close();
  142.                     }
  143.                 }catch(Throwable t) {
  144.                     // ignore
  145.                 }
  146.             }
  147.             return p;
  148.         }catch(Exception e){
  149.             throw new UtilsException(e.getMessage(), e);
  150.         }
  151.     }
  152.     public static String getSafeDefaultProtocol(){
  153.         try{
  154.             return getDefaultProtocol();
  155.         }catch(Exception e){
  156.             return SSLConstants.PROTOCOL_TLS;
  157.         }
  158.     }
  159.     public static String getDefaultProtocol() throws UtilsException{
  160.         // Ritorno l'ultima versione disponibile
  161.         List<String> p = getSSLSupportedProtocols();
  162.         if(p.contains(SSLConstants.PROTOCOL_TLS_V1_3)){
  163.             return SSLConstants.PROTOCOL_TLS_V1_3;
  164.         }
  165.         else if(p.contains(SSLConstants.PROTOCOL_TLS_V1_2)){
  166.             return SSLConstants.PROTOCOL_TLS_V1_2;
  167.         }
  168.         else if(p.contains(SSLConstants.PROTOCOL_TLS_V1_1)){
  169.             return SSLConstants.PROTOCOL_TLS_V1_1;
  170.         }
  171.         else if(p.contains(SSLConstants.PROTOCOL_TLS_V1)){
  172.             return SSLConstants.PROTOCOL_TLS_V1;
  173.         }
  174.         else if(p.contains(SSLConstants.PROTOCOL_TLS)){
  175.             return SSLConstants.PROTOCOL_TLS;
  176.         }
  177.         else if(p.contains(SSLConstants.PROTOCOL_SSL_V3)){
  178.             return SSLConstants.PROTOCOL_SSL_V3;
  179.         }
  180.         else if(p.contains(SSLConstants.PROTOCOL_SSL)){
  181.             return SSLConstants.PROTOCOL_SSL;
  182.         }
  183.         else if(p.contains(SSLConstants.PROTOCOL_SSL_V2_HELLO)){
  184.             return SSLConstants.PROTOCOL_SSL_V2_HELLO;
  185.         }
  186.         else{
  187.             return p.get(0);
  188.         }
  189.     }
  190.     public static List<String> getAllSslProtocol() {
  191.         // ritorno in ordine dal più recente al meno recento, più altri eventuali protocolli.
  192.         List<String> p = new ArrayList<>();
  193.         p.add(SSLConstants.PROTOCOL_TLS_V1_2);
  194.         p.add(SSLConstants.PROTOCOL_TLS_V1_1);
  195.         p.add(SSLConstants.PROTOCOL_TLS_V1);
  196.         p.add(SSLConstants.PROTOCOL_TLS); // per retrocompatibilità
  197.         p.add(SSLConstants.PROTOCOL_SSL_V3);
  198.         p.add(SSLConstants.PROTOCOL_SSL); // per retrocompatibilità
  199.         p.add(SSLConstants.PROTOCOL_SSL_V2_HELLO);
  200.         
  201.         try{
  202.             List<String> pTmp = getSSLSupportedProtocols();
  203.             for (String s : pTmp) {
  204.                 if(p.contains(s)==false){
  205.                     p.add(s);
  206.                 }
  207.             }
  208.         }catch(Exception e){
  209.             // non dovrebbe mai accadere una eccezione
  210.             e.printStackTrace(System.err);
  211.         }
  212.             
  213.         return  p;
  214.     }
  215.     
  216.     public static List<String> getSSLEnabledCipherSuites(String sslType) throws UtilsException{
  217.         try{
  218.             List<String> l = new ArrayList<>();
  219.             SSLContext context = SSLContext.getInstance(sslType);
  220.             context.init(null,null,null);
  221.             SSLSocket socket = null;
  222.             try {
  223.                 socket = (SSLSocket)context.getSocketFactory().createSocket();
  224.                 String[] cs = socket.getEnabledCipherSuites();
  225.                 for (int i = 0; i < cs.length; i++) {
  226.                     l.add(cs[i]);
  227.                 }
  228.             }finally {
  229.                 try {
  230.                     if(socket!=null) {
  231.                         socket.close();
  232.                     }
  233.                 }catch(Throwable t) {
  234.                     // ignore
  235.                 }
  236.             }
  237.             return l;
  238.         }catch(Exception e){
  239.             throw new UtilsException(e.getMessage(), e);
  240.         }
  241.     }
  242.     public static List<String> getSSLSupportedCipherSuites() throws UtilsException{
  243.         try{
  244.             List<String> l = new ArrayList<>();
  245.             SSLContext defaultContext = SSLContext.getDefault();
  246.             SSLSocket socket = null;
  247.             try {
  248.                 socket = (SSLSocket)defaultContext.getSocketFactory().createSocket();
  249.                 String[] cs = socket.getSupportedCipherSuites();
  250.                 for (int i = 0; i < cs.length; i++) {
  251.                     l.add(cs[i]);
  252.                 }
  253.             }finally {
  254.                 try {
  255.                     if(socket!=null) {
  256.                         socket.close();
  257.                     }
  258.                 }catch(Throwable t) {
  259.                     // ignore
  260.                 }
  261.             }
  262.             return l;
  263.         }catch(Exception e){
  264.             throw new UtilsException(e.getMessage(), e);
  265.         }
  266.     }
  267.         
  268.     
  269.     public static List<Provider> getSSLProviders() throws UtilsException{
  270.         try{
  271.             List<Provider> p = new ArrayList<>();
  272.             for (Provider provider : Security.getProviders()){
  273.                 p.add(provider);
  274.             }
  275.             return p;
  276.         }catch(Exception e){
  277.             throw new UtilsException(e.getMessage(), e);
  278.         }
  279.     }
  280.     public static List<String> getSSLProvidersName() throws UtilsException{
  281.         try{
  282.             List<String> p = new ArrayList<>();
  283.             for (Provider provider : Security.getProviders()){
  284.                 p.add(provider.getName());
  285.             }
  286.             return p;
  287.         }catch(Exception e){
  288.             throw new UtilsException(e.getMessage(), e);
  289.         }
  290.     }
  291.     public static List<String> getServiceTypes(Provider provider) throws UtilsException{
  292.         try{
  293.             List<String> p = new ArrayList<>();
  294.             for (Service service : provider.getServices()){
  295.                 if(!p.contains(service.getType())){
  296.                     p.add(service.getType());
  297.                 }
  298.             }
  299.             return p;
  300.         }catch(Exception e){
  301.             throw new UtilsException(e.getMessage(), e);
  302.         }
  303.     }
  304.     public static List<String> getServiceTypeAlgorithms(Provider provider,String serviceType) throws UtilsException{
  305.         try{
  306.             List<String> p = new ArrayList<>();
  307.             for (Service service : provider.getServices()){
  308.                 if(serviceType.equals(service.getType())){
  309.                     p.add(service.getAlgorithm());
  310.                 }
  311.             }
  312.             return p;
  313.         }catch(Exception e){
  314.             throw new UtilsException(e.getMessage(), e);
  315.         }
  316.     }
  317.     
  318.     private static TrustManager[] trustAllCertsManager;
  319.     private static synchronized void initTrustAllCertsManager() {
  320.         if(trustAllCertsManager==null) {
  321.             // Create a trust manager that does not validate certificate chains
  322.             trustAllCertsManager = new TrustManager[]{
  323.                 new SSLTrustAllManager()
  324.             };
  325.         }
  326.     }
  327.     public static TrustManager[] getTrustAllCertsManager() {
  328.         if(trustAllCertsManager==null) {
  329.             initTrustAllCertsManager();
  330.         }
  331.         return trustAllCertsManager;
  332.     }
  333.     
  334.     public static SSLContext generateSSLContext(SSLConfig sslConfig, StringBuilder bfLog) throws UtilsException{
  335.         return generateSSLContext(sslConfig, null, null, bfLog);
  336.     }
  337.     public static SSLContext generateSSLContext(SSLConfig sslConfig, IOCSPValidator ocspValidator, IBYOKUnwrapManager byok, StringBuilder bfLog) throws UtilsException{

  339.         // Gestione https
  340.         SSLContext sslContext = null;
  341.         
  342.         bfLog.append("Creo contesto SSL...\n");
  343.         KeyManager[] km = null;
  344.         TrustManager[] tm = null;

  346.         InputStream finKeyStore = null;
  347.         InputStream finTrustStore = null;
  348.         try{
  349.                     
  350.             // Autenticazione CLIENT
  351.             if(sslConfig.getKeyStore()!=null || sslConfig.getKeyStoreLocation()!=null){
  352.                 bfLog.append("Gestione keystore...\n");
  353.                 bfLog.append("\tKeystore type["+sslConfig.getKeyStoreType()+"]\n");
  354.                 bfLog.append("\tKeystore location["+sslConfig.getKeyStoreLocation()+"]\n");
  355.                 /**bfLog.append("\tKeystore password["+sslConfig.getKeyStorePassword()+"]\n");*/
  356.                 bfLog.append("\tKeystore byok policy["+sslConfig.getKeyStoreBYOKPolicy()+"]\n");
  357.                 bfLog.append("\tKeystore keyManagementAlgorithm["+sslConfig.getKeyManagementAlgorithm()+"]\n");
  358.                 /**bfLog.append("\tKeystore keyPassword["+sslConfig.getKeyPassword()+"]\n");*/
  359.                 String location = null;
  360.                 try {
  361.                     location = sslConfig.getKeyStoreLocation(); // per debug
  362.                 
  363.                     boolean hsmKeystore = false;
  364.                     HSMManager hsmManager = HSMManager.getInstance();
  365.                     if(hsmManager!=null) {
  366.                         if(sslConfig.getKeyStore()!=null) {
  367.                             hsmKeystore = sslConfig.isKeyStoreHsm();
  368.                         }
  369.                         else {
  370.                             if(sslConfig.getKeyStoreType()!=null && hsmManager.existsKeystoreType(sslConfig.getKeyStoreType())) {
  371.                                 hsmKeystore = true;
  372.                             }
  373.                         }
  374.                     }
  375.                     bfLog.append("\tKeystore HSM["+hsmManager+"]\n");
  376.                     
  377.                     KeyStore keystore = null;
  378.                     KeyStore keystoreParam = null;
  379.                     @SuppressWarnings("unused")
  380.                     Provider keystoreProvider = null;
  381.                     if(sslConfig.getKeyStore()!=null) {
  382.                         keystoreParam = sslConfig.getKeyStore();
  383.                         if(hsmKeystore) {
  384.                             keystoreProvider = keystoreParam.getProvider();
  385.                         }
  386.                     }
  387.                     else {
  388.                         if(hsmKeystore) {
  389.                             org.openspcoop2.utils.certificate.KeyStore ks = hsmManager.getKeystore(sslConfig.getKeyStoreType());
  390.                             if(ks==null) {
  391.                                 throw new UtilsException("Keystore not found");
  392.                             }
  393.                             keystoreParam = ks.getKeystore();
  394.                             keystoreProvider = keystoreParam.getProvider();
  395.                         }
  396.                         else {
  397.                             File file = new File(location);
  398.                             if(file.exists()) {
  399.                                 finKeyStore = new FileInputStream(file);
  400.                             }
  401.                             else {
  402.                                 finKeyStore = SSLUtilities.class.getResourceAsStream(location);
  403.                             }
  404.                             if(finKeyStore == null) {
  405.                                 throw new UtilsException("Keystore not found");
  406.                             }
  407.                             if(byok!=null) {
  408.                                 byte [] keystoreEncBytes = Utilities.getAsByteArray(finKeyStore);
  409.                                 byte [] keystorePlainBytes = byok.unwrap(keystoreEncBytes);
  410.                                 keystoreParam = KeystoreUtils.readKeystore(keystorePlainBytes, sslConfig.getKeyStoreType(), sslConfig.getKeyStorePassword());
  411.                             }
  412.                             else {
  413.                                 keystoreParam = KeystoreUtils.readKeystore(finKeyStore, sslConfig.getKeyStoreType(), sslConfig.getKeyStorePassword());
  414.                             }
  415.                         }
  416.                     }
  417.                     
  418.                     boolean oldMethodKeyAlias = false; // Questo metodo non funzionava con PKCS11
  419.                     if(oldMethodKeyAlias && sslConfig.getKeyAlias()!=null) {
  420.                         Key key = keystoreParam.getKey(sslConfig.getKeyAlias(), sslConfig.getKeyPassword().toCharArray());
  421.                         if(key==null) {
  422.                             throw new UtilsException("Key with alias '"+sslConfig.getKeyAlias()+"' not found");
  423.                         }
  424.                         if(hsmKeystore) {
  425.                             // uso un JKS come tmp
  426.                             keystore = KeyStore.getInstance(KeystoreType.JKS.getNome());
  427.                         }
  428.                         else {
  429.                             keystore = KeyStore.getInstance(sslConfig.getKeyStoreType());
  430.                         }
  431.                         keystore.load(null); // inizializza il keystore
  432.                         keystore.setKeyEntry(sslConfig.getKeyAlias(), key, 
  433.                                 sslConfig.getKeyPassword()!=null ? sslConfig.getKeyPassword().toCharArray() : "".toCharArray(), 
  434.                                 keystoreParam.getCertificateChain(sslConfig.getKeyAlias()));
  435.                     }
  436.                     else {
  437.                         keystore = keystoreParam;
  438.                     }
  439.                     
  440.                     KeyManagerFactory keyManagerFactory = null;
  441.                     // NO: no such algorithm: SunX509 for provider SunPKCS11-xxx
  442.                     /**if(keystoreProvider!=null) {
  443.                     //  keyManagerFactory = KeyManagerFactory.getInstance(sslConfig.getKeyManagementAlgorithm(), keystoreProvider);
  444.                     //}
  445.                     //else {*/
  446.                     keyManagerFactory = KeyManagerFactory.getInstance(sslConfig.getKeyManagementAlgorithm());
  447.                     
  448.                     keyManagerFactory.init(keystore, sslConfig.getKeyPassword()!=null ? sslConfig.getKeyPassword().toCharArray() : "".toCharArray());
  449.                     km = keyManagerFactory.getKeyManagers();
  450.                     if(!oldMethodKeyAlias && sslConfig.getKeyAlias()!=null &&
  451.                         km!=null && km.length>0 && km[0]!=null && km[0] instanceof X509KeyManager) {
  452.                             
  453.                         String alias = sslConfig.getKeyAlias();
  454.                         
  455.                         // Fix case insensitive
  456.                         Enumeration<String> enAliases = keystore.aliases();
  457.                         if(enAliases!=null) {
  458.                             while (enAliases.hasMoreElements()) {
  459.                                 String a = enAliases.nextElement();
  460.                                 if(a.equalsIgnoreCase(alias)) {
  461.                                     alias = a; // uso quello presente nel keystore
  462.                                     break;
  463.                                 }
  464.                             }
  465.                         }
  466.                         
  467.                         X509KeyManager wrapperX509KeyManager = new SSLX509ManagerForcedClientAlias(alias, (X509KeyManager)km[0] );
  468.                         km[0] = wrapperX509KeyManager;
  469.                     }
  470.                     bfLog.append("Gestione keystore effettuata\n");
  471.                 }catch(Throwable e) {
  472.                     if(location!=null) {
  473.                         throw new UtilsException("["+location+"] "+e.getMessage(),e);
  474.                     }
  475.                     else {
  476.                         throw new UtilsException(e.getMessage(),e);
  477.                     }
  478.                 }
  479.             }
  480.     
  481.     
  482.             // Autenticazione SERVER
  483.             KeyStore truststoreParam = null;
  484.             if(sslConfig.isTrustAllCerts()) {
  485.                 bfLog.append("Gestione trust all certs...\n");
  486.                 tm = getTrustAllCertsManager();
  487.                 bfLog.append("Gestione trust all certs effettuata\n");
  488.             }
  489.             else if(sslConfig.getTrustStore()!=null || sslConfig.getTrustStoreLocation()!=null){
  490.                 bfLog.append("Gestione truststore...\n");
  491.                 bfLog.append("\tTruststore type["+sslConfig.getTrustStoreType()+"]\n");
  492.                 bfLog.append("\tTruststore location["+sslConfig.getTrustStoreLocation()+"]\n");
  493.                 /**bfLog.append("\tTruststore password["+sslConfig.getTrustStorePassword()+"]\n");*/
  494.                 bfLog.append("\tTruststore trustManagementAlgorithm["+sslConfig.getTrustManagementAlgorithm()+"]\n");
  495.                 String location = null;
  496.                 try {
  497.                     location = sslConfig.getTrustStoreLocation(); // per debug
  498.                     
  499.                     boolean hsmTruststore = false;
  500.                     HSMManager hsmManager = HSMManager.getInstance();
  501.                     if(hsmManager!=null) {
  502.                         if(sslConfig.getTrustStore()!=null) {
  503.                             hsmTruststore = sslConfig.isTrustStoreHsm();
  504.                         }
  505.                         else {
  506.                             if(sslConfig.getTrustStoreType()!=null && hsmManager.existsKeystoreType(sslConfig.getTrustStoreType())) {
  507.                                 hsmTruststore = true;
  508.                             }
  509.                         }
  510.                     }
  511.                     bfLog.append("\tTruststore HSM["+hsmTruststore+"]\n");
  512.                     
  513.                     @SuppressWarnings("unused")
  514.                     Provider truststoreProvider = null;
  515.                     if(sslConfig.getTrustStore()!=null) {
  516.                         truststoreParam = sslConfig.getTrustStore();
  517.                         if(hsmTruststore) {
  518.                             truststoreProvider = truststoreParam.getProvider();
  519.                         }
  520.                     }
  521.                     else {
  522.                         if(hsmTruststore) {
  523.                             org.openspcoop2.utils.certificate.KeyStore ks = hsmManager.getKeystore(sslConfig.getTrustStoreType());
  524.                             if(ks==null) {
  525.                                 throw new UtilsException("Truststore not found");
  526.                             }
  527.                             truststoreParam = ks.getKeystore();
  528.                             truststoreProvider = truststoreParam.getProvider();
  529.                         }
  530.                         else {
  531.                             File file = new File(location);
  532.                             if(file.exists()) {
  533.                                 finTrustStore = new FileInputStream(file);
  534.                             }
  535.                             else {
  536.                                 finTrustStore = SSLUtilities.class.getResourceAsStream(location);
  537.                             }
  538.                             if(finTrustStore == null) {
  539.                                 throw new UtilsException("Truststore not found");
  540.                             }       
  541.                             truststoreParam = KeystoreUtils.readKeystore(finTrustStore, sslConfig.getTrustStoreType(), sslConfig.getTrustStorePassword());
  542.                         }
  543.                     }
  544.                     
  545.                     TrustManagerFactory trustManagerFactory = null;
  546.                     // NO: no such algorithm: PKIX for provider SunPKCS11-xxx
  547.                     /**if(truststoreProvider!=null) {
  548.                     //  trustManagerFactory = TrustManagerFactory.getInstance(sslConfig.getTrustManagementAlgorithm(), truststoreProvider);
  549.                     //}
  550.                     //else {*/
  551.                     trustManagerFactory = TrustManagerFactory.getInstance(sslConfig.getTrustManagementAlgorithm());
  552.                     
  553.                     String trustManagementAlgo = sslConfig.getTrustManagementAlgorithm();
  554.                     if(trustManagementAlgo!=null) {
  555.                         trustManagementAlgo = trustManagementAlgo.trim();
  556.                     }
  557.                     if("PKIX".equalsIgnoreCase(trustManagementAlgo)) {
  558.                     
  559.                          // create the parameters for the validator
  560.                         if(sslConfig.getTrustStoreCRLs()!=null) {
  561.                             bfLog.append("\tTruststore CRLs\n");
  562.                         }
  563.                         else if(sslConfig.getTrustStoreCRLsLocation()!=null) {
  564.                             bfLog.append("\tTruststore CRLs["+sslConfig.getTrustStoreCRLsLocation()+"]\n");
  565.                         }
  566.                         
  567.                         Provider sigProvider = null;
  568.                         CertPathTrustManagerParameters params = buildCertPathTrustManagerParameters(truststoreParam, sslConfig.getTrustStoreCRLs(), sslConfig.getTrustStoreCRLsLocation(), sigProvider);
  569.                         trustManagerFactory.init(params);
  570.                         
  571.                     }
  572.                     else {
  573.                     
  574.                         trustManagerFactory.init(truststoreParam);
  575.                         
  576.                     }
  577.                     tm = trustManagerFactory.getTrustManagers();
  578.                     bfLog.append("Gestione truststore effettuata\n");
  579.                 }catch(Throwable e) {
  580.                     if(location!=null) {
  581.                         throw new UtilsException("["+location+"] "+e.getMessage(),e);
  582.                     }
  583.                     else {
  584.                         throw new UtilsException(e.getMessage(),e);
  585.                     }
  586.                 }
  587.             }
  588.             
  589.             if(ocspValidator!=null) {
  590.                 if(ocspValidator.getTrustStore()==null && truststoreParam!=null) {
  591.                     ocspValidator.setTrustStore(new org.openspcoop2.utils.certificate.KeyStore(truststoreParam));
  592.                 }
  593.                 tm = OCSPTrustManager.wrap(tm, ocspValidator);
  594.                 ocspValidator.setOCSPTrustManager(OCSPTrustManager.read(tm));
  595.             }
  596.     
  597.             // Creo contesto SSL
  598.             bfLog.append("Init SSLContext type["+sslConfig.getSslType()+"] ...\n");
  599.             sslContext = SSLContext.getInstance(sslConfig.getSslType());
  600.             if(sslConfig.isSecureRandom()) {
  601.                 RandomGenerator randomGenerator = null;
  602.                 if(sslConfig.getSecureRandomAlgorithm()!=null && !"".equals(sslConfig.getSecureRandomAlgorithm())) {
  603.                     bfLog.append("Creazione Secure Random con algoritmo '"+sslConfig.getSecureRandomAlgorithm()+"' ...\n");
  604.                     randomGenerator = new RandomGenerator(true, sslConfig.getSecureRandomAlgorithm());
  605.                     bfLog.append("Creazione Secure Random con algoritmo '"+sslConfig.getSecureRandomAlgorithm()+"' effettuata\n");
  606.                 }
  607.                 else {
  608.                     bfLog.append("Creazione Secure Random ...\n");
  609.                     randomGenerator = new RandomGenerator(true);
  610.                     bfLog.append("Creazione Secure Random effettuata\n");
  611.                 }
  612.                 java.security.SecureRandom secureRandom = (java.security.SecureRandom) randomGenerator.getRandomEngine();
  613.                 bfLog.append("Inizializzazione SSLContext con Secure Random ...\n");
  614.                 sslContext.init(km, tm, secureRandom);
  615.             }
  616.             else {
  617.                 sslContext.init(km, tm, null);
  618.             }
  619.             
  620.             
  621.             if(sslContext.getClientSessionContext()!=null) {
  622.                 bfLog.append("ClientSessionContext size:").
  623.                     append(sslContext.getClientSessionContext().getSessionCacheSize()).
  624.                     append(" timeout:").
  625.                     append(sslContext.getClientSessionContext().getSessionTimeout()).append("\n");
  626.             }
  627.             if(sslContext.getServerSessionContext()!=null) {
  628.                 bfLog.append("ServerSessionContext size:").
  629.                     append(sslContext.getServerSessionContext().getSessionCacheSize()).
  630.                     append(" timeout:").
  631.                     append(sslContext.getServerSessionContext().getSessionTimeout()).append("\n");
  632.             }
  633.             
  634.             bfLog.append("Init SSLContext type["+sslConfig.getSslType()+"] effettuato\n");
  635.             
  636.             return sslContext;
  637.             
  638.         }catch(Exception e){
  639.             throw new UtilsException(e.getMessage(), e);
  640.         }
  641.         finally{
  642.             try{
  643.                 if(finKeyStore!=null){
  644.                     finKeyStore.close();
  645.                 }
  646.             }catch(Exception e){
  647.                 // close
  648.             }
  649.             try{
  650.                 if(finTrustStore!=null){
  651.                     finTrustStore.close();
  652.                 }
  653.             }catch(Exception e){
  654.                 // close
  655.             }
  656.         }
  657.     }
  658.     
  659.     public static CertPathTrustManagerParameters buildCertPathTrustManagerParameters(KeyStore truststoreParam,
  660.             CertStore crlStore, String crlLocation, Provider provider) throws Exception {
  661.         
  662.          // create the parameters for the validator
  663.         
  664.         // Ricreo il truststore altrimenti i certificati presenti come coppia (chiave privata e pubblica non sono trusted)
  665.         KeyStore truststore = KeyStore.getInstance(KeyStore.getDefaultType()); // JKS
  666.         truststore.load(null); // inizializza il truststore
  667.         Enumeration<String> aliases = truststoreParam.aliases();
  668.         while (aliases.hasMoreElements()) {
  669.             String alias = aliases.nextElement();
  670.             /** System.out.println("ALIAS: '"+alias+"'"); */
  671.             truststore.setCertificateEntry(alias, truststoreParam.getCertificate(alias));
  672.         }
  673.         
  674.         PKIXBuilderParameters pkixParams = new PKIXBuilderParameters(truststore, new X509CertSelector());
  675.         pkixParams.setRevocationEnabled(false);
  676.         pkixParams.setDate(DateManager.getDate());
  677.         
  678.         /**
  679.         java.security.cert.PKIXRevocationChecker revocationChecker =
  680.                 (java.security.cert.PKIXRevocationChecker) java.security.cert.CertPathBuilder.getInstance(trustManagementAlgo).getRevocationChecker();
  681.         pkixParams.addCertPathChecker(revocationChecker);
  682.         revocationChecker.setOcspResponder(uriResponse);
  683.         */
  684.                         
  685.         if(crlStore!=null || crlLocation!=null) {
  686.             CertStore crlsCertstore = null;
  687.             if(crlStore!=null) {
  688.                 crlsCertstore = crlStore;
  689.             }else {
  690.                 crlsCertstore = buildCRLCertStoreEngine(crlLocation);
  691.             }
  692.             pkixParams.addCertStore(crlsCertstore);
  693.             pkixParams.setRevocationEnabled(true);
  694.         }
  695.         
  696.         if(provider!=null) {
  697.             pkixParams.setSigProvider(provider.getName());
  698.         }
  699.         
  700.         return new CertPathTrustManagerParameters(pkixParams);
  701.         
  702.     }
  703.     
  704.     private static CertStore buildCRLCertStoreEngine(String crlsPath) throws Exception {
  705.         List<byte[]> crlBytes = new ArrayList<>();
  706.         List<String> crlPathsList = new ArrayList<>();
  707.         if(crlsPath.contains(",")) {
  708.             String [] tmp = crlsPath.split(",");
  709.             for (String crlPath : tmp) {
  710.                 crlPathsList.add(crlPath.trim());
  711.             }
  712.         }
  713.         else {
  714.             crlPathsList.add(crlsPath.trim());
  715.         }
  716.         for (String crlPath : crlPathsList) {
  717.             InputStream isStore = null;
  718.             try{
  719.                 File fStore = new File(crlPath);
  720.                 if(fStore.exists()){
  721.                     isStore = new FileInputStream(fStore);
  722.                 }else{
  723.                     isStore = SSLUtilities.class.getResourceAsStream(crlPath);
  724.                 }
  725.                 if(isStore==null){
  726.                     throw new UtilsException("CRL ["+crlPath+"] not found");
  727.                 }
  728.                 crlBytes.add(Utilities.getAsByteArray(isStore));
  729.             }finally{
  730.                 try{
  731.                     if(isStore!=null){
  732.                         isStore.close();
  733.                     }
  734.                 }catch(Exception eClose){
  735.                     // close
  736.                 }
  737.             }
  738.         }
  739.         List<X509CRL> caCrls = new ArrayList<>();
  740.         CertificateFactory certFactory = org.openspcoop2.utils.certificate.CertificateFactory.getCertificateFactory();
  741.         for (int i = 0; i < crlBytes.size(); i++) {
  742.             byte [] crl = crlBytes.get(i);
  743.             try(ByteArrayInputStream bin = new ByteArrayInputStream(crl)){
  744.                 X509CRL caCrl = (X509CRL) certFactory.generateCRL(bin); 
  745.                 caCrls.add(caCrl);
  746.             }
  747.             catch(Exception e){
  748.                 throw new SecurityException("Error loading CRL '"+crlPathsList.get(i)+"': "+e.getMessage(),e);
  749.             }
  750.         }
  751.         try {
  752.             CollectionCertStoreParameters certStoreParams =
  753.                         new CollectionCertStoreParameters(caCrls);
  754.             return CertStore.getInstance("Collection", certStoreParams);
  755.         }catch(Exception e){
  756.             throw new SecurityException("Build CertStore failed: "+e.getMessage(),e);
  757.         }
  758.     }

  760.     
  761.     public static HostnameVerifier generateHostnameVerifier(SSLConfig sslConfig, StringBuilder bfLog, Logger log, Loader loader) throws UtilsException{
  762.         try{
  763.             if(sslConfig.isHostnameVerifier()){
  764.                 if(sslConfig.getClassNameHostnameVerifier()!=null){
  765.                     bfLog.append("HostNamve verifier enabled ["+sslConfig.getClassNameHostnameVerifier()+"]\n");
  766.                     return (HostnameVerifier) loader.newInstance(sslConfig.getClassNameHostnameVerifier());
  767.                 }else{
  768.                     bfLog.append("HostName verifier enabled\n");
  769.                     return null;
  770.                 }
  771.             }else{
  772.                 bfLog.append("HostName verifier disabled\n");
  773.                 SSLHostNameVerifierDisabled disabilitato = new SSLHostNameVerifierDisabled(log);
  774.                 return disabilitato;
  775.             }
  776.         }catch(Exception e){
  777.             throw new UtilsException(e.getMessage(), e);
  778.         }
  779.         
  780.     }
  781.     
  782.     
  783.     public static void setSSLContextIntoJavaProperties(SSLConfig sslConfig, StringBuilder bfLog) throws UtilsException{

  785.         bfLog.append("Creo contesto SSL...\n");

  787.         try{
  788.         
  789.             // Autenticazione CLIENT
  790.             if(sslConfig.getKeyStoreLocation()!=null){
  791.                 bfLog.append("Gestione keystore...\n");
  792.                 
  793.                 System.setProperty("javax.net.ssl.keyStore", sslConfig.getKeyStoreLocation());
  794.                 if(sslConfig.getKeyStoreType()!=null){
  795.                     System.setProperty("javax.net.ssl.keyStoreType", sslConfig.getKeyStoreType());
  796.                 }
  797.                 if(sslConfig.getKeyStorePassword()!=null){
  798.                     System.setProperty("javax.net.ssl.keyStorePassword", sslConfig.getKeyStorePassword());
  799.                 }
  800.                 if(sslConfig.getKeyPassword()!=null){
  801.                     System.setProperty("javax.net.ssl.keyStorePassword", sslConfig.getKeyStorePassword());
  802.                     if(sslConfig.getKeyStorePassword()!=null){
  803.                         if(!sslConfig.getKeyPassword().equals(sslConfig.getKeyStorePassword())){
  804.                             throw new UtilsException("Keystore and key password in java must be equals");
  805.                         }
  806.                     }
  807.                 }
  808.                 
  809.                 bfLog.append("Gestione keystore effettuata\n");
  810.             }
  811.     
  812.     
  813.             // Autenticazione SERVER
  814.             if(sslConfig.getTrustStoreLocation()!=null){
  815.                 bfLog.append("Gestione truststore...\n");
  816.                 
  817.                 System.setProperty("javax.net.ssl.trustStore", sslConfig.getTrustStoreLocation());
  818.                 if(sslConfig.getKeyStoreType()!=null){
  819.                     System.setProperty("javax.net.ssl.trustStoreType", sslConfig.getTrustStoreType());
  820.                 }
  821.                 if(sslConfig.getKeyStorePassword()!=null){
  822.                     System.setProperty("javax.net.ssl.trustStorePassword", sslConfig.getTrustStorePassword());
  823.                 }
  824.                 
  825.                 bfLog.append("Gestione truststore effettuata\n");
  826.             }
  827.             
  828.         }catch(Exception e){
  829.             throw new UtilsException(e.getMessage(), e);
  830.         }

  832.     }
  833.     
  834.     public static String readPeerCertificates(String host, int port) throws UtilsException{
  835.         try {
  836.             
  837.             SSLContext sslContext = SSLContext.getInstance(SSLUtilities.getDefaultProtocol());
  838.             KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
  839.             TrustManagerFactory tmf =
  840.                     TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
  841.             tmf.init(ks);
  842.             X509TrustManager defaultTrustManager = (X509TrustManager)tmf.getTrustManagers()[0];
  843.             SSLSavingTrustManager   tm = new SSLSavingTrustManager(defaultTrustManager);
  844.             sslContext.init(null, new TrustManager[] {tm}, null);
  845.             
  846.             SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
  847.             
  848.             SSLSocket sslSocket = null;
  849.             try {
  850.                 sslSocket = (SSLSocket) sslSocketFactory.createSocket(host, port);
  851.                 sslSocket.setSoTimeout(10000);
  852.                 sslSocket.setWantClientAuth(false);
  853.                 try {
  854.                     sslSocket.startHandshake();
  855.                 }catch(Throwable t) {
  856.                     // ignore
  857.                 }
  858.             }finally {
  859.                 try {
  860.                     if(sslSocket!=null) {
  861.                         sslSocket.close();
  862.                     }
  863.                 }catch(Throwable t) {
  864.                     // ignore
  865.                 }
  866.             }
  867.             Certificate [] certs = tm.getPeerCertificates();
  868.             if(certs == null || certs.length<=0) {
  869.                 throw new UtilsException("Peer Certificates not found");
  870.             }
  871.             StringBuilder sb = new StringBuilder();
  872.             for (Certificate certificate : certs) {

  874.                 StringWriter sw = new StringWriter();
  875.                 JcaPEMWriter pemWriter = new JcaPEMWriter(sw);
  876.                 pemWriter.writeObject(certificate);
  877.                 pemWriter.close();
  878.                 sw.close();
  879.                 sb.append(sw.toString());

  881.             }
  882.             
  883.             return sb.toString();
  884.             
  885.         }catch(Exception e){
  886.             throw new UtilsException(e.getMessage(), e);
  887.         }
  888.     }
  889.     
  890.     public static java.security.cert.X509Certificate[] readCertificatesFromUndertowServlet(HttpServletRequest req) {
  891.         return readCertificatesFromUndertowServlet(req, null);
  892.     }
  893.     public static java.security.cert.X509Certificate[] readCertificatesFromUndertowServlet(HttpServletRequest reqParam, Logger log) {
  894.         try {
  895.             HttpServletRequest req = reqParam;
  896.             if(reqParam instanceof WrappedHttpServletRequest) {
  897.                 req = ((WrappedHttpServletRequest)reqParam).httpServletRequest;
  898.             }
  899.             
  900.             String undertow = "io.undertow.servlet.spec.HttpServletRequestImpl";
  901.             String actual = req.getClass().getName() + "";
  902.             boolean isUndertow = undertow.equals(actual);
  903.             
  904.             if(isUndertow) {
  905.                 
  906.                 // io/undertow/server/HttpServerExchange.java
  907.                 Method mExchange = req.getClass().getMethod("getExchange");
  908.                 if(mExchange!=null) {
  909.                     Object exchange = mExchange.invoke(req);
  910.                     if(exchange!=null) {
  911.                         /**System.out.println("Exchange ["+exchange.getClass().getName()+"]");*/
  912.                         
  913.                         // io/undertow/server/ServerConnection.java
  914.                         Method mConnection = exchange.getClass().getMethod("getConnection");
  915.                         if(mConnection!=null) {
  916.                             Object connection = mConnection.invoke(exchange);
  917.                             if(connection!=null) {
  918.                                 /**System.out.println("Connection ["+connection.getClass().getName()+"]");*/
  919.                                 
  920.                                 // io/undertow/server/SSLSessionInfo.java
  921.                                 Method mSSLSessionInfo = connection.getClass().getMethod("getSslSessionInfo");
  922.                                 if(mSSLSessionInfo!=null) {
  923.                                     Object sslSessionInfo = mSSLSessionInfo.invoke(connection);
  924.                                     if(sslSessionInfo!=null) {
  925.                                         /**System.out.println("sslSessionInfo ["+sslSessionInfo.getClass().getName()+"]");*/
  926.                                         
  927.                                         Method mPeerCertificates = sslSessionInfo.getClass().getMethod("getPeerCertificates");
  928.                                         if(mPeerCertificates!=null) {
  929.                                             try {
  930.                                                 Object peerCertificates = mPeerCertificates.invoke(sslSessionInfo);
  931.                                                 if(peerCertificates instanceof java.security.cert.X509Certificate[]) {
  932.                                                     return (java.security.cert.X509Certificate[]) peerCertificates;
  933.                                                 }
  934.                                             }catch(Throwable t) {
  935.                                                 // a volte lancia eccezione null .... 
  936.                                                 if(Utilities.existsInnerException(t, "io.undertow.server.RenegotiationRequiredException")) {
  937.                                                     return null; // certificati non sono disponibili a causa di una rinegoziazione
  938.                                                 }
  939.                                                 else {
  940.                                                     if(log!=null) {
  941.                                                         log.error("readCertificatesFromUndertowServlet 'get peer certificates' failed: "+t.getMessage(),t);
  942.                                                     }
  943.                                                 }
  944.                                             }
  945.                                         }
  946.                                     }
  947.                                 }
  948.                             }
  949.                         }
  950.                     }
  951.                 }
  952.             }
  953.         }catch(Throwable t) {
  954.             if(log!=null) {
  955.                 log.error("readCertificatesFromUndertowServlet failed: "+t.getMessage(),t);
  956.             }
  957.         }
  958.         return null;
  959.     }
  960. }
Created with JaCoCo 0.8.8.202204050719