GestoreKeystoreCache.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.security.keystore.cache;

  23. import java.security.cert.X509Certificate;
  24. import java.util.ArrayList;
  25. import java.util.Arrays;
  26. import java.util.List;
  27. import java.util.Map;

  29. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  30. import org.openspcoop2.security.SecurityException;
  31. import org.openspcoop2.security.keystore.BYOKStore;
  32. import org.openspcoop2.security.keystore.CRLCertstore;
  33. import org.openspcoop2.security.keystore.ExternalResource;
  34. import org.openspcoop2.security.keystore.HttpStore;
  35. import org.openspcoop2.security.keystore.JWKSetStore;
  36. import org.openspcoop2.security.keystore.KeyPairStore;
  37. import org.openspcoop2.security.keystore.MerlinKeystore;
  38. import org.openspcoop2.security.keystore.MerlinTruststore;
  39. import org.openspcoop2.security.keystore.MultiKeystore;
  40. import org.openspcoop2.security.keystore.OCSPResponse;
  41. import org.openspcoop2.security.keystore.PublicKeyStore;
  42. import org.openspcoop2.security.keystore.RemoteStore;
  43. import org.openspcoop2.security.keystore.SSLConfigProps;
  44. import org.openspcoop2.security.keystore.SSLSocketFactory;
  45. import org.openspcoop2.security.keystore.SecretKeyStore;
  46. import org.openspcoop2.security.keystore.SecretPasswordKeyDerivationConfig;
  47. import org.openspcoop2.security.keystore.SymmetricKeystore;
  48. import org.openspcoop2.utils.cache.Cache;
  49. import org.openspcoop2.utils.certificate.CertificateInfo;
  50. import org.openspcoop2.utils.certificate.byok.BYOKInstance;
  51. import org.openspcoop2.utils.certificate.byok.BYOKRequestParams;
  52. import org.openspcoop2.utils.certificate.remote.IRemoteStoreProvider;
  53. import org.openspcoop2.utils.certificate.remote.RemoteKeyType;
  54. import org.openspcoop2.utils.certificate.remote.RemoteStoreClientInfo;
  55. import org.openspcoop2.utils.certificate.remote.RemoteStoreConfig;
  56. import org.openspcoop2.utils.transport.http.ExternalResourceConfig;
  57. import org.openspcoop2.utils.transport.http.HttpOptions;
  58. import org.openspcoop2.utils.transport.http.IOCSPValidator;
  59. import org.openspcoop2.utils.transport.http.SSLConfig;

  61. /**
  62.  * GestoreKeystoreCache
  63.  *
  64.  * @author Andrea Poli (apoli@link.it)
  65.  * @author $Author$
  66.  * @version $Rev$, $Date$
  67.  */
  68. public class GestoreKeystoreCache {
  69.     
  70.     private GestoreKeystoreCache() {}

  72.     private static final MerlinTruststoreCache merlinTruststoreCache = new MerlinTruststoreCache();
  73.     private static final MerlinKeystoreCache merlinKeystoreCache = new MerlinKeystoreCache();
  74.     private static final SymmetricKeystoreCache symmetricKeystoreCache = new SymmetricKeystoreCache();
  75.     private static final MultiKeystoreCache multiKeystoreCache = new MultiKeystoreCache();
  76.     private static final JWKSetStoreCache jwkSetStoreCache = new JWKSetStoreCache();
  77.     private static final KeyPairStoreCache keyPairStoreCache = new KeyPairStoreCache();
  78.     private static final PublicKeyStoreCache publicKeyStoreCache = new PublicKeyStoreCache();
  79.     private static final SecretKeyStoreCache secretKeyStoreCache = new SecretKeyStoreCache();
  80.     private static final RemoteStoreCache remoteStoreCache = new RemoteStoreCache();
  81.     private static final RemoteStoreClientInfoCache remoteStoreClientInfoCache = new RemoteStoreClientInfoCache();
  82.     private static final HttpStoreCache httpStoreCache = new HttpStoreCache();
  83.     private static final BYOKStoreCache byokStoreCache = new BYOKStoreCache();
  84.     private static final CRLCertstoreCache crlCertstoreCache = new CRLCertstoreCache();
  85.     private static final SSLSocketFactoryCache sslSocketFactoryCache = new SSLSocketFactoryCache();
  86.     private static final SSLConfigPropsCache sslConfigPropsCache = new SSLConfigPropsCache();
  87.     private static final ExternalResourceCache externalResourceCache = new ExternalResourceCache();
  88.     private static final OCSPResponseCache ocspResponseCache = new OCSPResponseCache();
  89.     private static boolean cacheEnabled = false;
  90.     
  91.     public static void setKeystoreCacheParameters(boolean cacheEnabled,int cacheLifeSecond,int cacheSize){
  92.         GestoreKeystoreCache.cacheEnabled = cacheEnabled;
  93.         GestoreKeystoreCache.merlinTruststoreCache.setKeystoreCacheParameters(cacheLifeSecond, cacheSize);
  94.         GestoreKeystoreCache.merlinKeystoreCache.setKeystoreCacheParameters(cacheLifeSecond, cacheSize);
  95.         GestoreKeystoreCache.symmetricKeystoreCache.setKeystoreCacheParameters(cacheLifeSecond, cacheSize);
  96.         GestoreKeystoreCache.multiKeystoreCache.setKeystoreCacheParameters(cacheLifeSecond, cacheSize);
  97.         GestoreKeystoreCache.jwkSetStoreCache.setKeystoreCacheParameters(cacheLifeSecond, cacheSize);
  98.         GestoreKeystoreCache.keyPairStoreCache.setKeystoreCacheParameters(cacheLifeSecond, cacheSize);
  99.         GestoreKeystoreCache.publicKeyStoreCache.setKeystoreCacheParameters(cacheLifeSecond, cacheSize);
  100.         GestoreKeystoreCache.secretKeyStoreCache.setKeystoreCacheParameters(cacheLifeSecond, cacheSize);
  101.         GestoreKeystoreCache.remoteStoreCache.setKeystoreCacheParameters(cacheLifeSecond, cacheSize);
  102.         GestoreKeystoreCache.remoteStoreClientInfoCache.setKeystoreCacheParameters(cacheLifeSecond, cacheSize);
  103.         GestoreKeystoreCache.httpStoreCache.setKeystoreCacheParameters(cacheLifeSecond, cacheSize);
  104.         GestoreKeystoreCache.byokStoreCache.setKeystoreCacheParameters(cacheLifeSecond, cacheSize);
  105.         GestoreKeystoreCache.crlCertstoreCache.setKeystoreCacheParameters(cacheLifeSecond, cacheSize);
  106.         GestoreKeystoreCache.sslSocketFactoryCache.setKeystoreCacheParameters(cacheLifeSecond, cacheSize);
  107.         GestoreKeystoreCache.sslConfigPropsCache.setKeystoreCacheParameters(cacheLifeSecond, cacheSize);
  108.         GestoreKeystoreCache.externalResourceCache.setKeystoreCacheParameters(cacheLifeSecond, cacheSize);
  109.         GestoreKeystoreCache.ocspResponseCache.setKeystoreCacheParameters(cacheLifeSecond, cacheSize);
  110.     }
  111.     public static void setKeystoreCacheJCS(boolean cacheEnabled,int cacheLifeSecond, Cache cacheJCS){
  112.         GestoreKeystoreCache.cacheEnabled = cacheEnabled;
  113.         GestoreKeystoreCache.merlinTruststoreCache.setCacheJCS(cacheLifeSecond, cacheJCS);
  114.         GestoreKeystoreCache.merlinKeystoreCache.setCacheJCS(cacheLifeSecond, cacheJCS);
  115.         GestoreKeystoreCache.symmetricKeystoreCache.setCacheJCS(cacheLifeSecond, cacheJCS);
  116.         GestoreKeystoreCache.multiKeystoreCache.setCacheJCS(cacheLifeSecond, cacheJCS);
  117.         GestoreKeystoreCache.jwkSetStoreCache.setCacheJCS(cacheLifeSecond, cacheJCS);
  118.         GestoreKeystoreCache.keyPairStoreCache.setCacheJCS(cacheLifeSecond, cacheJCS);
  119.         GestoreKeystoreCache.publicKeyStoreCache.setCacheJCS(cacheLifeSecond, cacheJCS);
  120.         GestoreKeystoreCache.secretKeyStoreCache.setCacheJCS(cacheLifeSecond, cacheJCS);
  121.         GestoreKeystoreCache.remoteStoreCache.setCacheJCS(cacheLifeSecond, cacheJCS);
  122.         GestoreKeystoreCache.remoteStoreClientInfoCache.setCacheJCS(cacheLifeSecond, cacheJCS);
  123.         GestoreKeystoreCache.httpStoreCache.setCacheJCS(cacheLifeSecond, cacheJCS);
  124.         GestoreKeystoreCache.byokStoreCache.setCacheJCS(cacheLifeSecond, cacheJCS);
  125.         GestoreKeystoreCache.crlCertstoreCache.setCacheJCS(cacheLifeSecond, cacheJCS);
  126.         GestoreKeystoreCache.sslSocketFactoryCache.setCacheJCS(cacheLifeSecond, cacheJCS);
  127.         GestoreKeystoreCache.sslConfigPropsCache.setCacheJCS(cacheLifeSecond, cacheJCS);
  128.         GestoreKeystoreCache.externalResourceCache.setCacheJCS(cacheLifeSecond, cacheJCS);
  129.         GestoreKeystoreCache.ocspResponseCache.setCacheJCS(cacheLifeSecond, cacheJCS);
  130.     }
  131.     public static void setKeystoreCacheJCSCrlLifeSeconds(int cacheCrlLifeSecond){
  132.         GestoreKeystoreCache.crlCertstoreCache.updateCacheLifeSecond(cacheCrlLifeSecond);
  133.         GestoreKeystoreCache.ocspResponseCache.updateCacheLifeSecond(cacheCrlLifeSecond);
  134.         GestoreKeystoreCache.externalResourceCache.updateCacheLifeSecond(cacheCrlLifeSecond); // Per adesso utilizzo la stessa impostazione che consente di indicare un tempo minore rispetto al resto della cache
  135.     }
  136.     
  137.     
  138.     public static MerlinTruststore getMerlinTruststore(RequestInfo requestInfo, String propertyFilePath) throws SecurityException{
  139.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && propertyFilePath!=null;
  140.         if(useRequestInfo) {
  141.             Object o = requestInfo.getRequestConfig().getMerlinTruststore(propertyFilePath);
  142.             if(o instanceof MerlinTruststore) {
  143.                 return (MerlinTruststore) o;
  144.             }
  145.         }
  146.         MerlinTruststore t = null;
  147.         if(GestoreKeystoreCache.cacheEnabled)
  148.             t = GestoreKeystoreCache.merlinTruststoreCache.getKeystoreAndCreateIfNotExists(propertyFilePath);
  149.         else
  150.             t = new MerlinTruststore(propertyFilePath);
  151.         if(useRequestInfo) {
  152.             requestInfo.getRequestConfig().addMerlinTruststore(propertyFilePath, t, requestInfo.getIdTransazione());
  153.         }
  154.         return t;
  155.     }
  156.     public static MerlinTruststore getMerlinTruststore(RequestInfo requestInfo, String pathStore,String tipoStore,String passwordStore) throws SecurityException{
  157.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && pathStore!=null;
  158.         if(useRequestInfo) {
  159.             Object o = requestInfo.getRequestConfig().getMerlinTruststore(pathStore);
  160.             if(o instanceof MerlinTruststore) {
  161.                 return (MerlinTruststore) o;
  162.             }
  163.         }
  164.         MerlinTruststore t = null;
  165.         if(GestoreKeystoreCache.cacheEnabled)
  166.             t = GestoreKeystoreCache.merlinTruststoreCache.getKeystoreAndCreateIfNotExists(pathStore, tipoStore, passwordStore);
  167.         else
  168.             t = new MerlinTruststore(pathStore, tipoStore, passwordStore);
  169.         if(useRequestInfo) {
  170.             requestInfo.getRequestConfig().addMerlinTruststore(pathStore, t, requestInfo.getIdTransazione());
  171.         }
  172.         return t;
  173.     }
  174.     public static MerlinTruststore getMerlinTruststore(RequestInfo requestInfo, byte[] bytesStore,String tipoStore,String passwordStore) throws SecurityException{
  175.         String keyParam = null;
  176.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && bytesStore!=null;
  177.         if(useRequestInfo) {
  178.             keyParam = AbstractKeystoreCache.buildKeyCacheFromBytes(bytesStore);
  179.             Object o = requestInfo.getRequestConfig().getMerlinTruststore(keyParam);
  180.             if(o instanceof MerlinTruststore) {
  181.                 return (MerlinTruststore) o;
  182.             }
  183.         }
  184.         MerlinTruststore t = null;
  185.         if(GestoreKeystoreCache.cacheEnabled)
  186.             t = GestoreKeystoreCache.merlinTruststoreCache.getKeystoreAndCreateIfNotExists(bytesStore, tipoStore, passwordStore);
  187.         else
  188.             t = new MerlinTruststore(bytesStore, tipoStore, passwordStore);
  189.         if(useRequestInfo) {
  190.             requestInfo.getRequestConfig().addMerlinTruststore(keyParam, t, requestInfo.getIdTransazione());
  191.         }
  192.         return t;
  193.     }
  194.     
  195.     
  196.     public static MerlinKeystore getMerlinKeystore(RequestInfo requestInfo, String propertyFilePath) throws SecurityException{
  197.         return getMerlinKeystore(requestInfo, propertyFilePath, 
  198.                 (BYOKRequestParams) null);
  199.     }
  200.     public static MerlinKeystore getMerlinKeystore(RequestInfo requestInfo, String propertyFilePath, 
  201.             BYOKRequestParams requestParams) throws SecurityException{
  202.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && propertyFilePath!=null;
  203.         if(useRequestInfo) {
  204.             Object o = requestInfo.getRequestConfig().getMerlinKeystore(propertyFilePath);
  205.             if(o instanceof MerlinKeystore) {
  206.                 return (MerlinKeystore) o;
  207.             }
  208.         }
  209.         MerlinKeystore k = null;
  210.         if(requestParams!=null) {
  211.             if(GestoreKeystoreCache.cacheEnabled)
  212.                 k = GestoreKeystoreCache.merlinKeystoreCache.getKeystoreAndCreateIfNotExists(propertyFilePath, requestParams);
  213.             else
  214.                 k = new MerlinKeystore(propertyFilePath, requestParams);
  215.         }
  216.         else {
  217.             if(GestoreKeystoreCache.cacheEnabled)
  218.                 k = GestoreKeystoreCache.merlinKeystoreCache.getKeystoreAndCreateIfNotExists(propertyFilePath);
  219.             else
  220.                 k = new MerlinKeystore(propertyFilePath);
  221.         }
  222.         if(useRequestInfo) {
  223.             requestInfo.getRequestConfig().addMerlinKeystore(propertyFilePath, k, requestInfo.getIdTransazione());
  224.         }
  225.         return k;
  226.     }
  227.     
  228.     public static MerlinKeystore getMerlinKeystore(RequestInfo requestInfo, String propertyFilePath,String passwordPrivateKey) throws SecurityException{
  229.         return getMerlinKeystore(requestInfo, propertyFilePath, passwordPrivateKey, 
  230.                 (BYOKRequestParams) null);
  231.     }
  232.     public static MerlinKeystore getMerlinKeystore(RequestInfo requestInfo, String propertyFilePath,String passwordPrivateKey, 
  233.             BYOKRequestParams requestParams) throws SecurityException{
  234.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && propertyFilePath!=null;
  235.         if(useRequestInfo) {
  236.             Object o = requestInfo.getRequestConfig().getMerlinKeystore(propertyFilePath);
  237.             if(o instanceof MerlinKeystore) {
  238.                 return (MerlinKeystore) o;
  239.             }
  240.         }
  241.         MerlinKeystore k = null;
  242.         if(requestParams!=null) {
  243.             if(GestoreKeystoreCache.cacheEnabled)
  244.                 k = GestoreKeystoreCache.merlinKeystoreCache.getKeystoreAndCreateIfNotExists(propertyFilePath, passwordPrivateKey, requestParams);
  245.             else
  246.                 k = new MerlinKeystore(propertyFilePath, passwordPrivateKey, requestParams);
  247.         }
  248.         else {
  249.             if(GestoreKeystoreCache.cacheEnabled)
  250.                 k = GestoreKeystoreCache.merlinKeystoreCache.getKeystoreAndCreateIfNotExists(propertyFilePath, passwordPrivateKey);
  251.             else
  252.                 k = new MerlinKeystore(propertyFilePath, passwordPrivateKey);
  253.         }
  254.         if(useRequestInfo) {
  255.             requestInfo.getRequestConfig().addMerlinKeystore(propertyFilePath, k, requestInfo.getIdTransazione());
  256.         }
  257.         return k;
  258.     }
  259.     
  260.     public static MerlinKeystore getMerlinKeystore(RequestInfo requestInfo, String pathStore,String tipoStore,String passwordStore) throws SecurityException{
  261.         return getMerlinKeystore(requestInfo, pathStore, tipoStore, passwordStore, 
  262.                 (BYOKRequestParams) null);
  263.     }
  264.     public static MerlinKeystore getMerlinKeystore(RequestInfo requestInfo, String pathStore,String tipoStore,String passwordStore, 
  265.             BYOKRequestParams requestParams) throws SecurityException{
  266.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && pathStore!=null;
  267.         if(useRequestInfo) {
  268.             Object o = requestInfo.getRequestConfig().getMerlinKeystore(pathStore);
  269.             if(o instanceof MerlinKeystore) {
  270.                 return (MerlinKeystore) o;
  271.             }
  272.         }
  273.         MerlinKeystore k = null;
  274.         if(requestParams!=null) {
  275.             if(GestoreKeystoreCache.cacheEnabled)
  276.                 k = GestoreKeystoreCache.merlinKeystoreCache.getKeystoreAndCreateIfNotExists(pathStore, tipoStore, passwordStore, requestParams);
  277.             else
  278.                 k = new MerlinKeystore(pathStore, tipoStore, passwordStore, requestParams);
  279.         }
  280.         else {
  281.             if(GestoreKeystoreCache.cacheEnabled)
  282.                 k = GestoreKeystoreCache.merlinKeystoreCache.getKeystoreAndCreateIfNotExists(pathStore, tipoStore, passwordStore);
  283.             else
  284.                 k = new MerlinKeystore(pathStore, tipoStore, passwordStore);
  285.         }
  286.         if(useRequestInfo) {
  287.             requestInfo.getRequestConfig().addMerlinKeystore(pathStore, k, requestInfo.getIdTransazione());
  288.         }
  289.         return k;
  290.     }
  291.     
  292.     public static MerlinKeystore getMerlinKeystore(RequestInfo requestInfo, String pathStore,String tipoStore,String passwordStore,String passwordPrivateKey) throws SecurityException{
  293.         return getMerlinKeystore(requestInfo, pathStore, tipoStore, passwordStore, passwordPrivateKey, 
  294.                 (BYOKRequestParams) null);
  295.     }
  296.     public static MerlinKeystore getMerlinKeystore(RequestInfo requestInfo, String pathStore,String tipoStore,String passwordStore,String passwordPrivateKey, 
  297.             BYOKRequestParams requestParams) throws SecurityException{
  298.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && pathStore!=null;
  299.         if(useRequestInfo) {
  300.             Object o = requestInfo.getRequestConfig().getMerlinKeystore(pathStore);
  301.             if(o instanceof MerlinKeystore) {
  302.                 return (MerlinKeystore) o;
  303.             }
  304.         }
  305.         MerlinKeystore k = null;
  306.         if(requestParams!=null) {
  307.             if(GestoreKeystoreCache.cacheEnabled)
  308.                 k = GestoreKeystoreCache.merlinKeystoreCache.getKeystoreAndCreateIfNotExists(pathStore, tipoStore, passwordStore, passwordPrivateKey, requestParams);
  309.             else
  310.                 k = new MerlinKeystore(pathStore, tipoStore, passwordStore, passwordPrivateKey, requestParams);
  311.         }
  312.         else {
  313.             if(GestoreKeystoreCache.cacheEnabled)
  314.                 k = GestoreKeystoreCache.merlinKeystoreCache.getKeystoreAndCreateIfNotExists(pathStore, tipoStore, passwordStore, passwordPrivateKey);
  315.             else
  316.                 k = new MerlinKeystore(pathStore, tipoStore, passwordStore, passwordPrivateKey);
  317.         }
  318.         if(useRequestInfo) {
  319.             requestInfo.getRequestConfig().addMerlinKeystore(pathStore, k, requestInfo.getIdTransazione());
  320.         }
  321.         return k;
  322.     }
  323.     
  324.     public static MerlinKeystore getMerlinKeystore(RequestInfo requestInfo, byte[] bytesStore,String tipoStore,String passwordStore) throws SecurityException{
  325.         return getMerlinKeystore(requestInfo, bytesStore, tipoStore, passwordStore, 
  326.                 (BYOKRequestParams) null);
  327.     }
  328.     public static MerlinKeystore getMerlinKeystore(RequestInfo requestInfo, byte[] bytesStore,String tipoStore,String passwordStore, 
  329.             BYOKRequestParams requestParams) throws SecurityException{
  330.         String keyParam = null;
  331.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && bytesStore!=null;
  332.         if(useRequestInfo) {
  333.             keyParam = AbstractKeystoreCache.buildKeyCacheFromBytes(bytesStore);
  334.             Object o = requestInfo.getRequestConfig().getMerlinKeystore(keyParam);
  335.             if(o instanceof MerlinKeystore) {
  336.                 return (MerlinKeystore) o;
  337.             }
  338.         }
  339.         MerlinKeystore k = null;
  340.         if(requestParams!=null) {
  341.             if(GestoreKeystoreCache.cacheEnabled)
  342.                 k = GestoreKeystoreCache.merlinKeystoreCache.getKeystoreAndCreateIfNotExists(bytesStore, tipoStore, passwordStore, requestParams);
  343.             else
  344.                 k = new MerlinKeystore(bytesStore, tipoStore, passwordStore, requestParams);
  345.         }
  346.         else {
  347.             if(GestoreKeystoreCache.cacheEnabled)
  348.                 k = GestoreKeystoreCache.merlinKeystoreCache.getKeystoreAndCreateIfNotExists(bytesStore, tipoStore, passwordStore);
  349.             else
  350.                 k = new MerlinKeystore(bytesStore, tipoStore, passwordStore);
  351.         }
  352.         if(useRequestInfo) {
  353.             requestInfo.getRequestConfig().addMerlinKeystore(keyParam, k, requestInfo.getIdTransazione());
  354.         }
  355.         return k;
  356.     }
  357.     
  358.     public static MerlinKeystore getMerlinKeystore(RequestInfo requestInfo,byte[] bytesStore,String tipoStore,String passwordStore,String passwordPrivateKey) throws SecurityException{
  359.         return getMerlinKeystore(requestInfo, bytesStore, tipoStore, passwordStore,passwordPrivateKey, 
  360.                 (BYOKRequestParams) null);
  361.     }
  362.     public static MerlinKeystore getMerlinKeystore(RequestInfo requestInfo,byte[] bytesStore,String tipoStore,String passwordStore,String passwordPrivateKey, 
  363.             BYOKRequestParams requestParams) throws SecurityException{
  364.         String keyParam = null;
  365.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && bytesStore!=null;
  366.         if(useRequestInfo) {
  367.             keyParam = AbstractKeystoreCache.buildKeyCacheFromBytes(bytesStore);
  368.             Object o = requestInfo.getRequestConfig().getMerlinKeystore(keyParam);
  369.             if(o instanceof MerlinKeystore) {
  370.                 return (MerlinKeystore) o;
  371.             }
  372.         }
  373.         MerlinKeystore k = null;
  374.         if(requestParams!=null) {
  375.             if(GestoreKeystoreCache.cacheEnabled)
  376.                 k = GestoreKeystoreCache.merlinKeystoreCache.getKeystoreAndCreateIfNotExists(bytesStore, tipoStore, passwordStore, passwordPrivateKey, requestParams);
  377.             else
  378.                 k = new MerlinKeystore(bytesStore, tipoStore, passwordStore, passwordPrivateKey, requestParams);
  379.         }
  380.         else {
  381.             if(GestoreKeystoreCache.cacheEnabled)
  382.                 k = GestoreKeystoreCache.merlinKeystoreCache.getKeystoreAndCreateIfNotExists(bytesStore, tipoStore, passwordStore, passwordPrivateKey);
  383.             else
  384.                 k = new MerlinKeystore(bytesStore, tipoStore, passwordStore, passwordPrivateKey);
  385.         }
  386.         if(useRequestInfo) {
  387.             requestInfo.getRequestConfig().addMerlinKeystore(keyParam, k, requestInfo.getIdTransazione());
  388.         }
  389.         return k;
  390.     }
  391.     
  392.     
  393.     public static SymmetricKeystore getSymmetricKeystore(RequestInfo requestInfo, String alias,String key,String algoritmo) throws SecurityException{
  394.         return getSymmetricKeystore(requestInfo, alias, key, algoritmo, 
  395.                 (BYOKRequestParams) null);
  396.     }
  397.     public static SymmetricKeystore getSymmetricKeystore(RequestInfo requestInfo, String alias,String key,String algoritmo, 
  398.             BYOKRequestParams requestParams) throws SecurityException{
  399.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && key!=null;
  400.         if(useRequestInfo) {
  401.             Object o = requestInfo.getRequestConfig().getSymmetricKeystore(key);
  402.             if(o instanceof SymmetricKeystore) {
  403.                 return (SymmetricKeystore) o;
  404.             }
  405.         }
  406.         SymmetricKeystore k = null;
  407.         if(requestParams!=null) {
  408.             if(GestoreKeystoreCache.cacheEnabled)
  409.                 k = GestoreKeystoreCache.symmetricKeystoreCache.getKeystoreAndCreateIfNotExists(key, alias, algoritmo, requestParams);
  410.             else
  411.                 k = new SymmetricKeystore(alias, key, algoritmo, requestParams);
  412.         }
  413.         else {
  414.             if(GestoreKeystoreCache.cacheEnabled)
  415.                 k = GestoreKeystoreCache.symmetricKeystoreCache.getKeystoreAndCreateIfNotExists(key, alias, algoritmo);
  416.             else
  417.                 k = new SymmetricKeystore(alias, key, algoritmo);
  418.         }
  419.         if(useRequestInfo) {
  420.             requestInfo.getRequestConfig().addSymmetricKeystore(key, k, requestInfo.getIdTransazione());
  421.         }
  422.         return k;
  423.     }
  424.     
  425.     
  426.     public static MultiKeystore getMultiKeystore(RequestInfo requestInfo, String propertyFilePath) throws SecurityException{
  427.         return getMultiKeystore(requestInfo, propertyFilePath, 
  428.                 (BYOKRequestParams) null);
  429.     }
  430.     public static MultiKeystore getMultiKeystore(RequestInfo requestInfo, String propertyFilePath, 
  431.             BYOKRequestParams requestParams) throws SecurityException{
  432.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && propertyFilePath!=null;
  433.         if(useRequestInfo) {
  434.             Object o = requestInfo.getRequestConfig().getMultiKeystore(propertyFilePath);
  435.             if(o instanceof MultiKeystore) {
  436.                 return (MultiKeystore) o;
  437.             }
  438.         }
  439.         MultiKeystore k = null;
  440.         if(requestParams!=null) {
  441.             if(GestoreKeystoreCache.cacheEnabled)
  442.                 k = GestoreKeystoreCache.multiKeystoreCache.getKeystoreAndCreateIfNotExists(propertyFilePath, requestParams);
  443.             else
  444.                 k = new MultiKeystore(propertyFilePath, requestParams);
  445.         }
  446.         else {
  447.             if(GestoreKeystoreCache.cacheEnabled)
  448.                 k = GestoreKeystoreCache.multiKeystoreCache.getKeystoreAndCreateIfNotExists(propertyFilePath);
  449.             else
  450.                 k = new MultiKeystore(propertyFilePath);
  451.         }
  452.         if(useRequestInfo) {
  453.             requestInfo.getRequestConfig().addMultiKeystore(propertyFilePath, k, requestInfo.getIdTransazione());
  454.         }
  455.         return k;
  456.     }
  457.     
  458.     
  459.     public static JWKSetStore getJwkSetStore(RequestInfo requestInfo, String propertyFilePath) throws SecurityException{
  460.         return getJwkSetStore(requestInfo, propertyFilePath, 
  461.                 (BYOKRequestParams) null);
  462.     }
  463.     public static JWKSetStore getJwkSetStore(RequestInfo requestInfo, String propertyFilePath, 
  464.             BYOKRequestParams requestParams) throws SecurityException{
  465.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && propertyFilePath!=null;
  466.         if(useRequestInfo) {
  467.             Object o = requestInfo.getRequestConfig().getJWKSetStore(propertyFilePath);
  468.             if(o instanceof JWKSetStore) {
  469.                 return (JWKSetStore) o;
  470.             }
  471.         }
  472.         JWKSetStore k = null;
  473.         if(requestParams!=null) {
  474.             if(GestoreKeystoreCache.cacheEnabled)
  475.                 k = GestoreKeystoreCache.jwkSetStoreCache.getKeystoreAndCreateIfNotExists(propertyFilePath, requestParams);
  476.             else
  477.                 k = new JWKSetStore(propertyFilePath, requestParams);
  478.         }
  479.         else {
  480.             if(GestoreKeystoreCache.cacheEnabled)
  481.                 k = GestoreKeystoreCache.jwkSetStoreCache.getKeystoreAndCreateIfNotExists(propertyFilePath);
  482.             else
  483.                 k = new JWKSetStore(propertyFilePath);
  484.         }
  485.         if(useRequestInfo) {
  486.             requestInfo.getRequestConfig().addJWKSetStore(propertyFilePath, k, requestInfo.getIdTransazione());
  487.         }
  488.         return k;
  489.     }
  490.     
  491.     public static JWKSetStore getJwkSetStore(RequestInfo requestInfo, byte[] archive) throws SecurityException{
  492.         return getJwkSetStore(requestInfo, archive, 
  493.                 (BYOKRequestParams) null);
  494.     }
  495.     public static JWKSetStore getJwkSetStore(RequestInfo requestInfo, byte[] archive, 
  496.             BYOKRequestParams requestParams) throws SecurityException{
  497.         String keyParam = null;
  498.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && archive!=null;
  499.         if(useRequestInfo) {
  500.             keyParam = AbstractKeystoreCache.buildKeyCacheFromBytes(archive);
  501.             Object o = requestInfo.getRequestConfig().getJWKSetStore(keyParam);
  502.             if(o instanceof JWKSetStore) {
  503.                 return (JWKSetStore) o;
  504.             }
  505.         }
  506.         JWKSetStore k = null;
  507.         if(requestParams!=null) {
  508.             if(GestoreKeystoreCache.cacheEnabled)
  509.                 k = GestoreKeystoreCache.jwkSetStoreCache.getKeystoreAndCreateIfNotExists(archive, requestParams);
  510.             else
  511.                 k = new JWKSetStore(archive, requestParams);
  512.         }
  513.         else {
  514.             if(GestoreKeystoreCache.cacheEnabled)
  515.                 k = GestoreKeystoreCache.jwkSetStoreCache.getKeystoreAndCreateIfNotExists(archive);
  516.             else
  517.                 k = new JWKSetStore(archive);
  518.         }
  519.         if(useRequestInfo) {
  520.             requestInfo.getRequestConfig().addJWKSetStore(keyParam, k, requestInfo.getIdTransazione());
  521.         }
  522.         return k;
  523.     }
  524.     
  525.     
  526.     public static KeyPairStore getKeyPairStore(RequestInfo requestInfo, String privateKeyPath, String publicKeyPath, String privateKeyPassword, String algorithm) throws SecurityException{
  527.         return getKeyPairStore(requestInfo, privateKeyPath, publicKeyPath, privateKeyPassword, algorithm, 
  528.                 (BYOKRequestParams) null);
  529.     }
  530.     public static KeyPairStore getKeyPairStore(RequestInfo requestInfo, String privateKeyPath, String publicKeyPath, String privateKeyPassword, String algorithm, 
  531.             BYOKRequestParams requestParams) throws SecurityException{
  532.         // come chiave di cache si usa solo la chiave privata
  533.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && privateKeyPath!=null;
  534.         if(useRequestInfo) {
  535.             Object o = requestInfo.getRequestConfig().getKeyPairStore(privateKeyPath);
  536.             if(o instanceof KeyPairStore) {
  537.                 return (KeyPairStore) o;
  538.             }
  539.         }
  540.         KeyPairStore k = null;
  541.         if(requestParams!=null) {
  542.             if(GestoreKeystoreCache.cacheEnabled)
  543.                 k = GestoreKeystoreCache.keyPairStoreCache.getKeystoreAndCreateIfNotExists(privateKeyPath, publicKeyPath, privateKeyPassword, algorithm, requestParams);
  544.             else
  545.                 k = new KeyPairStore(privateKeyPath, publicKeyPath, privateKeyPassword, algorithm, requestParams);
  546.         }
  547.         else {
  548.             if(GestoreKeystoreCache.cacheEnabled)
  549.                 k = GestoreKeystoreCache.keyPairStoreCache.getKeystoreAndCreateIfNotExists(privateKeyPath, publicKeyPath, privateKeyPassword, algorithm);
  550.             else
  551.                 k = new KeyPairStore(privateKeyPath, publicKeyPath, privateKeyPassword, algorithm);
  552.         }
  553.         if(useRequestInfo) {
  554.             requestInfo.getRequestConfig().addKeyPairStore(privateKeyPath, k, requestInfo.getIdTransazione());
  555.         }
  556.         return k;
  557.     }
  558.     
  559.     public static KeyPairStore getKeyPairStore(RequestInfo requestInfo, String privateKeyPath, byte[] publicKey, String privateKeyPassword, String algorithm) throws SecurityException{
  560.         return getKeyPairStore(requestInfo, privateKeyPath, publicKey, privateKeyPassword, algorithm, 
  561.                 (BYOKRequestParams) null);
  562.     }
  563.     public static KeyPairStore getKeyPairStore(RequestInfo requestInfo, String privateKeyPath, byte[] publicKey, String privateKeyPassword, String algorithm, 
  564.             BYOKRequestParams requestParams) throws SecurityException{
  565.         // come chiave di cache si usa solo la chiave privata
  566.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && privateKeyPath!=null;
  567.         if(useRequestInfo) {
  568.             Object o = requestInfo.getRequestConfig().getKeyPairStore(privateKeyPath);
  569.             if(o instanceof KeyPairStore) {
  570.                 return (KeyPairStore) o;
  571.             }
  572.         }
  573.         KeyPairStore k = null;
  574.         if(requestParams!=null) {
  575.             if(GestoreKeystoreCache.cacheEnabled)
  576.                 k = GestoreKeystoreCache.keyPairStoreCache.getKeystoreAndCreateIfNotExists(privateKeyPath, publicKey, privateKeyPassword, algorithm, requestParams);
  577.             else
  578.                 k = new KeyPairStore(privateKeyPath, publicKey, privateKeyPassword, algorithm, requestParams);
  579.         }
  580.         else {
  581.             if(GestoreKeystoreCache.cacheEnabled)
  582.                 k = GestoreKeystoreCache.keyPairStoreCache.getKeystoreAndCreateIfNotExists(privateKeyPath, publicKey, privateKeyPassword, algorithm);
  583.             else
  584.                 k = new KeyPairStore(privateKeyPath, publicKey, privateKeyPassword, algorithm);
  585.         }
  586.         if(useRequestInfo) {
  587.             requestInfo.getRequestConfig().addKeyPairStore(privateKeyPath, k, requestInfo.getIdTransazione());
  588.         }
  589.         return k;
  590.     }
  591.     
  592.     public static KeyPairStore getKeyPairStore(RequestInfo requestInfo, byte[] privateKey, byte[] publicKey, String privateKeyPassword, String algorithm) throws SecurityException{
  593.         return getKeyPairStore(requestInfo, privateKey, publicKey, privateKeyPassword, algorithm, 
  594.                 (BYOKRequestParams) null);
  595.     }
  596.     public static KeyPairStore getKeyPairStore(RequestInfo requestInfo, byte[] privateKey, byte[] publicKey, String privateKeyPassword, String algorithm, 
  597.             BYOKRequestParams requestParams) throws SecurityException{
  598.         // come chiave di cache si usa solo la chiave privata
  599.         String keyParam = null;
  600.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && privateKey!=null;
  601.         if(useRequestInfo) {
  602.             keyParam = AbstractKeystoreCache.buildKeyCacheFromBytes(privateKey);
  603.             Object o = requestInfo.getRequestConfig().getKeyPairStore(keyParam);
  604.             if(o instanceof KeyPairStore) {
  605.                 return (KeyPairStore) o;
  606.             }
  607.         }
  608.         KeyPairStore k = null;
  609.         if(requestParams!=null) {
  610.             if(GestoreKeystoreCache.cacheEnabled)
  611.                 k = GestoreKeystoreCache.keyPairStoreCache.getKeystoreAndCreateIfNotExists(privateKey, publicKey, privateKeyPassword, algorithm, requestParams);
  612.             else
  613.                 k = new KeyPairStore(privateKey, publicKey, privateKeyPassword, algorithm, requestParams);
  614.         }
  615.         else {
  616.             if(GestoreKeystoreCache.cacheEnabled)
  617.                 k = GestoreKeystoreCache.keyPairStoreCache.getKeystoreAndCreateIfNotExists(privateKey, publicKey, privateKeyPassword, algorithm);
  618.             else
  619.                 k = new KeyPairStore(privateKey, publicKey, privateKeyPassword, algorithm);
  620.         }
  621.         if(useRequestInfo) {
  622.             requestInfo.getRequestConfig().addKeyPairStore(keyParam, k, requestInfo.getIdTransazione());
  623.         }
  624.         return k;
  625.     }
  626.     
  627.     public static KeyPairStore getKeyPairStore(RequestInfo requestInfo, byte[] privateKey, String publicKeyPath, String privateKeyPassword, String algorithm) throws SecurityException{
  628.         return getKeyPairStore(requestInfo, privateKey, publicKeyPath, privateKeyPassword, algorithm, 
  629.                 (BYOKRequestParams) null);
  630.     }
  631.     public static KeyPairStore getKeyPairStore(RequestInfo requestInfo, byte[] privateKey, String publicKeyPath, String privateKeyPassword, String algorithm, 
  632.             BYOKRequestParams requestParams) throws SecurityException{
  633.         // come chiave di cache si usa solo la chiave privata
  634.         String keyParam = null;
  635.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && privateKey!=null;
  636.         if(useRequestInfo) {
  637.             keyParam = AbstractKeystoreCache.buildKeyCacheFromBytes(privateKey);
  638.             Object o = requestInfo.getRequestConfig().getKeyPairStore(keyParam);
  639.             if(o instanceof KeyPairStore) {
  640.                 return (KeyPairStore) o;
  641.             }
  642.         }
  643.         KeyPairStore k = null;
  644.         if(requestParams!=null) {
  645.             if(GestoreKeystoreCache.cacheEnabled)
  646.                 k = GestoreKeystoreCache.keyPairStoreCache.getKeystoreAndCreateIfNotExists(privateKey, publicKeyPath, privateKeyPassword, algorithm, requestParams);
  647.             else
  648.                 k = new KeyPairStore(privateKey, publicKeyPath, privateKeyPassword, algorithm, requestParams);
  649.         }
  650.         else {
  651.             if(GestoreKeystoreCache.cacheEnabled)
  652.                 k = GestoreKeystoreCache.keyPairStoreCache.getKeystoreAndCreateIfNotExists(privateKey, publicKeyPath, privateKeyPassword, algorithm);
  653.             else
  654.                 k = new KeyPairStore(privateKey, publicKeyPath, privateKeyPassword, algorithm);
  655.         }
  656.         if(useRequestInfo) {
  657.             requestInfo.getRequestConfig().addKeyPairStore(keyParam, k, requestInfo.getIdTransazione());
  658.         }
  659.         return k;
  660.     }
  661.     
  662.     
  663.     
  664.     public static PublicKeyStore getPublicKeyStore(RequestInfo requestInfo, String publicKeyPath, String algorithm) throws SecurityException{
  665.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && publicKeyPath!=null;
  666.         if(useRequestInfo) {
  667.             Object o = requestInfo.getRequestConfig().getPublicKeyStore(publicKeyPath);
  668.             if(o instanceof PublicKeyStore) {
  669.                 return (PublicKeyStore) o;
  670.             }
  671.         }
  672.         PublicKeyStore k = null;
  673.         if(GestoreKeystoreCache.cacheEnabled)
  674.             k = GestoreKeystoreCache.publicKeyStoreCache.getKeystoreAndCreateIfNotExists(publicKeyPath, algorithm);
  675.         else
  676.             k = new PublicKeyStore(publicKeyPath, algorithm);
  677.         if(useRequestInfo) {
  678.             requestInfo.getRequestConfig().addPublicKeyStore(publicKeyPath, k, requestInfo.getIdTransazione());
  679.         }
  680.         return k;
  681.     }
  682.     public static PublicKeyStore getPublicKeyStore(RequestInfo requestInfo, byte[] publicKey, String algorithm) throws SecurityException{
  683.         String keyParam = null;
  684.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && publicKey!=null;
  685.         if(useRequestInfo) {
  686.             keyParam = AbstractKeystoreCache.buildKeyCacheFromBytes(publicKey);
  687.             Object o = requestInfo.getRequestConfig().getPublicKeyStore(keyParam);
  688.             if(o instanceof PublicKeyStore) {
  689.                 return (PublicKeyStore) o;
  690.             }
  691.         }
  692.         PublicKeyStore k = null;
  693.         if(GestoreKeystoreCache.cacheEnabled)
  694.             k = GestoreKeystoreCache.publicKeyStoreCache.getKeystoreAndCreateIfNotExists(publicKey, algorithm);
  695.         else
  696.             k = new PublicKeyStore(publicKey, algorithm);
  697.         if(useRequestInfo) {
  698.             requestInfo.getRequestConfig().addPublicKeyStore(keyParam, k, requestInfo.getIdTransazione());
  699.         }
  700.         return k;
  701.     }
  702.     
  703.     
  704.     
  705.     
  706.     
  707.     public static SecretKeyStore getSecretKeyStore(RequestInfo requestInfo, String secretKeyPath, String algorithm) throws SecurityException{
  708.         return getSecretKeyStore(requestInfo, secretKeyPath, algorithm, 
  709.                 (BYOKRequestParams) null);
  710.     }
  711.     public static SecretKeyStore getSecretKeyStore(RequestInfo requestInfo, String secretKeyPath, String algorithm, 
  712.             BYOKRequestParams requestParams) throws SecurityException{
  713.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && secretKeyPath!=null;
  714.         if(useRequestInfo) {
  715.             Object o = requestInfo.getRequestConfig().getSecretKeyStore(secretKeyPath);
  716.             if(o instanceof SecretKeyStore) {
  717.                 return (SecretKeyStore) o;
  718.             }
  719.         }
  720.         SecretKeyStore k = null;
  721.         if(requestParams!=null) {
  722.             if(GestoreKeystoreCache.cacheEnabled)
  723.                 k = GestoreKeystoreCache.secretKeyStoreCache.getKeystoreAndCreateIfNotExists(secretKeyPath, algorithm, requestParams);
  724.             else
  725.                 k = new SecretKeyStore(secretKeyPath, algorithm, requestParams);
  726.         }
  727.         else {
  728.             if(GestoreKeystoreCache.cacheEnabled)
  729.                 k = GestoreKeystoreCache.secretKeyStoreCache.getKeystoreAndCreateIfNotExists(secretKeyPath, algorithm);
  730.             else
  731.                 k = new SecretKeyStore(secretKeyPath, algorithm);
  732.         }
  733.         if(useRequestInfo) {
  734.             requestInfo.getRequestConfig().addSecretKeyStore(secretKeyPath, k, requestInfo.getIdTransazione());
  735.         }
  736.         return k;
  737.     }
  738.     
  739.     public static SecretKeyStore getSecretKeyStore(RequestInfo requestInfo, byte[] secretKey, String algorithm) throws SecurityException{
  740.         return getSecretKeyStore(requestInfo, secretKey, algorithm,
  741.                 (BYOKRequestParams) null);
  742.     }
  743.     public static SecretKeyStore getSecretKeyStore(RequestInfo requestInfo, byte[] secretKey, String algorithm, 
  744.             BYOKRequestParams requestParams) throws SecurityException{
  745.         String keyParam = null;
  746.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && secretKey!=null;
  747.         if(useRequestInfo) {
  748.             keyParam = AbstractKeystoreCache.buildKeyCacheFromBytes(secretKey);
  749.             Object o = requestInfo.getRequestConfig().getSecretKeyStore(keyParam);
  750.             if(o instanceof SecretKeyStore) {
  751.                 return (SecretKeyStore) o;
  752.             }
  753.         }
  754.         SecretKeyStore k = null;
  755.         if(requestParams!=null) {
  756.             if(GestoreKeystoreCache.cacheEnabled)
  757.                 k = GestoreKeystoreCache.secretKeyStoreCache.getKeystoreAndCreateIfNotExists(secretKey, algorithm, requestParams);
  758.             else
  759.                 k = new SecretKeyStore(secretKey, algorithm, requestParams);
  760.         }
  761.         else {
  762.             if(GestoreKeystoreCache.cacheEnabled)
  763.                 k = GestoreKeystoreCache.secretKeyStoreCache.getKeystoreAndCreateIfNotExists(secretKey, algorithm);
  764.             else
  765.                 k = new SecretKeyStore(secretKey, algorithm);
  766.         }
  767.         if(useRequestInfo) {
  768.             requestInfo.getRequestConfig().addSecretKeyStore(keyParam, k, requestInfo.getIdTransazione());
  769.         }
  770.         return k;
  771.     }
  772.     
  773.     public static SecretKeyStore getSecretKeyStore(RequestInfo requestInfo, SecretPasswordKeyDerivationConfig config) throws SecurityException{
  774.         return getSecretKeyStore(requestInfo, config,
  775.                 (BYOKRequestParams) null);
  776.     }
  777.     public static SecretKeyStore getSecretKeyStore(RequestInfo requestInfo, SecretPasswordKeyDerivationConfig config, 
  778.             BYOKRequestParams requestParams) throws SecurityException{
  779.         if(config==null) {
  780.             throw new SecurityException("SecretPasswordKeyDerivationConfig param undefined");
  781.         }
  782.         String keyParam = config.toKey();
  783.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && config!=null;
  784.         if(useRequestInfo) {
  785.             Object o = requestInfo.getRequestConfig().getSecretKeyStore(keyParam);
  786.             if(o instanceof SecretKeyStore) {
  787.                 return (SecretKeyStore) o;
  788.             }
  789.         }
  790.         SecretKeyStore k = null;
  791.         if(requestParams!=null) {
  792.             if(GestoreKeystoreCache.cacheEnabled)
  793.                 k = GestoreKeystoreCache.secretKeyStoreCache.getKeystoreAndCreateIfNotExists(keyParam, config, requestParams);
  794.             else
  795.                 k = new SecretKeyStore(config, requestParams);
  796.         }
  797.         else {
  798.             if(GestoreKeystoreCache.cacheEnabled)
  799.                 k = GestoreKeystoreCache.secretKeyStoreCache.getKeystoreAndCreateIfNotExists(keyParam, config);
  800.             else
  801.                 k = new SecretKeyStore(config);
  802.         }
  803.         if(useRequestInfo) {
  804.             requestInfo.getRequestConfig().addSecretKeyStore(keyParam, k, requestInfo.getIdTransazione());
  805.         }
  806.         return k;
  807.     }
  808.     
  809.     
  810.     
  811.     
  812.     
  813.     
  814.     public static RemoteStore getRemoteStore(RequestInfo requestInfo, String keyId, RemoteKeyType keyType, RemoteStoreConfig remoteStoreConfig, IRemoteStoreProvider provider) throws SecurityException{
  815.         
  816.         String keyCache = RemoteStoreCache.getKeyCache(remoteStoreConfig, keyId, keyType);
  817.         
  818.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && keyCache!=null;
  819.         if(useRequestInfo) {
  820.             Object o = requestInfo.getRequestConfig().getRemoteStore(keyCache);
  821.             if(o instanceof RemoteStore) {
  822.                 return (RemoteStore) o;
  823.             }
  824.         }
  825.         RemoteStore k = null;
  826.         if(GestoreKeystoreCache.cacheEnabled)
  827.             k = GestoreKeystoreCache.remoteStoreCache.getKeystoreAndCreateIfNotExists(keyCache, keyId, keyType, remoteStoreConfig, provider);
  828.         else
  829.             k = new RemoteStore(keyId, keyType, remoteStoreConfig, provider);
  830.         if(useRequestInfo) {
  831.             requestInfo.getRequestConfig().addRemoteStore(keyCache, k, requestInfo.getIdTransazione());
  832.         }
  833.         return k;
  834.     }
  835.     public static void removeRemoteStore(RequestInfo requestInfo, String keyId, RemoteKeyType keyType, RemoteStoreConfig remoteStoreConfig) throws SecurityException{
  836.         String keyCache = RemoteStoreCache.getKeyCache(remoteStoreConfig, keyId, keyType);
  837.         
  838.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && keyCache!=null;
  839.         if(useRequestInfo) {
  840.             requestInfo.getRequestConfig().removeRemoteStore(keyCache);
  841.         }
  842.         if(GestoreKeystoreCache.cacheEnabled) {
  843.             GestoreKeystoreCache.remoteStoreCache.removeObjectFromCache(keyCache);
  844.         }
  845.     }
  846.     public static List<String> keysRemoteStore() throws SecurityException{
  847.         List<String> l = null;
  848.         if(GestoreKeystoreCache.cacheEnabled) {
  849.             return GestoreKeystoreCache.remoteStoreCache.keys();
  850.         }
  851.         return l;
  852.     }
  853.     
  854.     
  855.     
  856.     
  857.     public static RemoteStoreClientInfo getRemoteStoreClientInfo(RequestInfo requestInfo, String keyId, String clientId, RemoteStoreConfig remoteStoreConfig, IRemoteStoreProvider provider,
  858.             org.openspcoop2.utils.Map<Object> context) throws SecurityException{
  859.         
  860.         String keyCache = RemoteStoreClientInfoCache.getKeyCache(remoteStoreConfig, keyId);
  861.         
  862.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && keyCache!=null;
  863.         if(useRequestInfo) {
  864.             Object o = requestInfo.getRequestConfig().getRemoteStoreClientInfo(keyCache);
  865.             if(o instanceof RemoteStoreClientInfo) {
  866.                 return (RemoteStoreClientInfo) o;
  867.             }
  868.         }
  869.         org.openspcoop2.security.keystore.RemoteStoreClientInfo k = null;
  870.         if(GestoreKeystoreCache.cacheEnabled)
  871.             k = GestoreKeystoreCache.remoteStoreClientInfoCache.getKeystoreAndCreateIfNotExists(keyCache, keyId, clientId, remoteStoreConfig, provider, context);
  872.         else
  873.             k = new org.openspcoop2.security.keystore.RemoteStoreClientInfo(keyId, clientId, remoteStoreConfig, provider, context);
  874.         if(useRequestInfo) {
  875.             requestInfo.getRequestConfig().addRemoteStoreClientInfo(keyCache, k, requestInfo.getIdTransazione());
  876.         }
  877.         return k.getClientInfo();
  878.     }
  879.     public static void removeRemoteStoreClientInfo(RequestInfo requestInfo, String keyId, RemoteStoreConfig remoteStoreConfig) throws SecurityException{
  880.         String keyCache = RemoteStoreClientInfoCache.getKeyCache(remoteStoreConfig, keyId);
  881.         
  882.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && keyCache!=null;
  883.         if(useRequestInfo) {
  884.             requestInfo.getRequestConfig().removeRemoteStoreClientInfo(keyCache);
  885.         }
  886.         if(GestoreKeystoreCache.cacheEnabled) {
  887.             GestoreKeystoreCache.remoteStoreClientInfoCache.removeObjectFromCache(keyCache);
  888.         }
  889.     }
  890.     
  891.     
  892.     
  893.     
  894.     public static HttpStore getHttpStore(RequestInfo requestInfo, String endpoint,
  895.             HttpOptions ... options) throws SecurityException{
  896.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && endpoint!=null;
  897.         if(useRequestInfo) {
  898.             Object o = requestInfo.getRequestConfig().getHttpStore(endpoint);
  899.             if(o instanceof HttpStore) {
  900.                 return (HttpStore) o;
  901.             }
  902.         }
  903.         HttpStore k = null;
  904.         if(GestoreKeystoreCache.cacheEnabled) {
  905.             if(options!=null && options.length>0) {
  906.                 List<HttpOptions> list = new ArrayList<>();
  907.                 list.addAll(Arrays.asList(options));
  908.                 k = GestoreKeystoreCache.httpStoreCache.getKeystoreAndCreateIfNotExists(endpoint,
  909.                         list);
  910.             }
  911.             else {
  912.                 k = GestoreKeystoreCache.httpStoreCache.getKeystoreAndCreateIfNotExists(endpoint);
  913.             }
  914.         }else
  915.             k = new HttpStore(endpoint,
  916.                     options);
  917.         if(useRequestInfo) {
  918.             requestInfo.getRequestConfig().addHttpStore(endpoint, k, requestInfo.getIdTransazione());
  919.         }
  920.         return k;
  921.     }
  922.     public static HttpStore getHttpStore(RequestInfo requestInfo, String endpoint, Integer connectionTimeout, Integer readTimeout,
  923.             HttpOptions ... options) throws SecurityException{
  924.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && endpoint!=null;
  925.         if(useRequestInfo) {
  926.             Object o = requestInfo.getRequestConfig().getHttpStore(endpoint);
  927.             if(o instanceof HttpStore) {
  928.                 return (HttpStore) o;
  929.             }
  930.         }
  931.         HttpStore k = null;
  932.         if(GestoreKeystoreCache.cacheEnabled)
  933.             k = GestoreKeystoreCache.httpStoreCache.getKeystoreAndCreateIfNotExists(endpoint, connectionTimeout, readTimeout,
  934.                     options);
  935.         else
  936.             k = new HttpStore(endpoint, connectionTimeout, readTimeout,
  937.                     options);
  938.         if(useRequestInfo) {
  939.             requestInfo.getRequestConfig().addHttpStore(endpoint, k, requestInfo.getIdTransazione());
  940.         }
  941.         return k;
  942.     }
  943.     public static HttpStore getHttpStore(RequestInfo requestInfo, String endpoint, MerlinTruststore trustStoreSsl,
  944.             HttpOptions ... options) throws SecurityException{
  945.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && endpoint!=null;
  946.         if(useRequestInfo) {
  947.             Object o = requestInfo.getRequestConfig().getHttpStore(endpoint);
  948.             if(o instanceof HttpStore) {
  949.                 return (HttpStore) o;
  950.             }
  951.         }
  952.         HttpStore k = null;
  953.         if(GestoreKeystoreCache.cacheEnabled)
  954.             k = GestoreKeystoreCache.httpStoreCache.getKeystoreAndCreateIfNotExists(endpoint, trustStoreSsl,
  955.                     options);
  956.         else
  957.             k = new HttpStore(endpoint, trustStoreSsl,
  958.                     options);
  959.         if(useRequestInfo) {
  960.             requestInfo.getRequestConfig().addHttpStore(endpoint, k, requestInfo.getIdTransazione());
  961.         }
  962.         return k;
  963.     }
  964.     public static HttpStore getHttpStore(RequestInfo requestInfo, String endpoint, MerlinTruststore trustStoreSsl, CRLCertstore crlTrustStoreSsl,
  965.             HttpOptions ... options) throws SecurityException{
  966.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && endpoint!=null;
  967.         if(useRequestInfo) {
  968.             Object o = requestInfo.getRequestConfig().getHttpStore(endpoint);
  969.             if(o instanceof HttpStore) {
  970.                 return (HttpStore) o;
  971.             }
  972.         }
  973.         HttpStore k = null;
  974.         if(GestoreKeystoreCache.cacheEnabled)
  975.             k = GestoreKeystoreCache.httpStoreCache.getKeystoreAndCreateIfNotExists(endpoint, trustStoreSsl, crlTrustStoreSsl,
  976.                     options);
  977.         else
  978.             k = new HttpStore(endpoint, trustStoreSsl, crlTrustStoreSsl,
  979.                     options);
  980.         if(useRequestInfo) {
  981.             requestInfo.getRequestConfig().addHttpStore(endpoint, k, requestInfo.getIdTransazione());
  982.         }
  983.         return k;
  984.     }
  985.     public static HttpStore getHttpStore(RequestInfo requestInfo, String endpoint, 
  986.             Integer connectionTimeout, Integer readTimeout,
  987.             MerlinTruststore trustStoreSsl,
  988.             HttpOptions ... options) throws SecurityException{
  989.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && endpoint!=null;
  990.         if(useRequestInfo) {
  991.             Object o = requestInfo.getRequestConfig().getHttpStore(endpoint);
  992.             if(o instanceof HttpStore) {
  993.                 return (HttpStore) o;
  994.             }
  995.         }
  996.         HttpStore k = null;
  997.         if(GestoreKeystoreCache.cacheEnabled)
  998.             k = GestoreKeystoreCache.httpStoreCache.getKeystoreAndCreateIfNotExists(endpoint, 
  999.                     connectionTimeout, readTimeout, 
  1000.                     trustStoreSsl,
  1001.                     options);
  1002.         else
  1003.             k = new HttpStore(endpoint, 
  1004.                     connectionTimeout, readTimeout, 
  1005.                     trustStoreSsl,
  1006.                     options);
  1007.         if(useRequestInfo) {
  1008.             requestInfo.getRequestConfig().addHttpStore(endpoint, k, requestInfo.getIdTransazione());
  1009.         }
  1010.         return k;
  1011.     }
  1012.     public static HttpStore getHttpStore(RequestInfo requestInfo,String endpoint, 
  1013.             Integer connectionTimeout, Integer readTimeout,
  1014.             MerlinTruststore trustStoreSsl, CRLCertstore crlTrustStoreSsl,
  1015.             HttpOptions ... options) throws SecurityException{
  1016.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && endpoint!=null;
  1017.         if(useRequestInfo) {
  1018.             Object o = requestInfo.getRequestConfig().getHttpStore(endpoint);
  1019.             if(o instanceof HttpStore) {
  1020.                 return (HttpStore) o;
  1021.             }
  1022.         }
  1023.         HttpStore k = null;
  1024.         if(GestoreKeystoreCache.cacheEnabled)
  1025.             k = GestoreKeystoreCache.httpStoreCache.getKeystoreAndCreateIfNotExists(endpoint, 
  1026.                     connectionTimeout, readTimeout, 
  1027.                     trustStoreSsl, crlTrustStoreSsl,
  1028.                     options);
  1029.         else
  1030.             k = new HttpStore(endpoint, 
  1031.                     connectionTimeout, readTimeout, 
  1032.                     trustStoreSsl, crlTrustStoreSsl,
  1033.                     options);
  1034.         if(useRequestInfo) {
  1035.             requestInfo.getRequestConfig().addHttpStore(endpoint, k, requestInfo.getIdTransazione());
  1036.         }
  1037.         return k;
  1038.     }
  1039.     public static HttpStore getHttpStore(RequestInfo requestInfo, String endpoint, Boolean trustAll,
  1040.             HttpOptions ... options) throws SecurityException{
  1041.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && endpoint!=null;
  1042.         if(useRequestInfo) {
  1043.             Object o = requestInfo.getRequestConfig().getHttpStore(endpoint);
  1044.             if(o instanceof HttpStore) {
  1045.                 return (HttpStore) o;
  1046.             }
  1047.         }
  1048.         HttpStore k = null;
  1049.         if(GestoreKeystoreCache.cacheEnabled)
  1050.             k = GestoreKeystoreCache.httpStoreCache.getKeystoreAndCreateIfNotExists(endpoint, trustAll,
  1051.                     options);
  1052.         else
  1053.             k = new HttpStore(endpoint, trustAll,
  1054.                     options);
  1055.         if(useRequestInfo) {
  1056.             requestInfo.getRequestConfig().addHttpStore(endpoint, k, requestInfo.getIdTransazione());
  1057.         }
  1058.         return k;
  1059.     }
  1060.     public static HttpStore getHttpStore(RequestInfo requestInfo, String endpoint, 
  1061.             Integer connectionTimeout, Integer readTimeout,
  1062.             Boolean trustAll,
  1063.             HttpOptions ... options) throws SecurityException{
  1064.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && endpoint!=null;
  1065.         if(useRequestInfo) {
  1066.             Object o = requestInfo.getRequestConfig().getHttpStore(endpoint);
  1067.             if(o instanceof HttpStore) {
  1068.                 return (HttpStore) o;
  1069.             }
  1070.         }
  1071.         HttpStore k = null;
  1072.         if(GestoreKeystoreCache.cacheEnabled)
  1073.             k = GestoreKeystoreCache.httpStoreCache.getKeystoreAndCreateIfNotExists(endpoint, 
  1074.                     connectionTimeout, readTimeout, 
  1075.                     trustAll,
  1076.                     options);
  1077.         else
  1078.             k = new HttpStore(endpoint, 
  1079.                     connectionTimeout, readTimeout, 
  1080.                     trustAll,
  1081.                     options);
  1082.         if(useRequestInfo) {
  1083.             requestInfo.getRequestConfig().addHttpStore(endpoint, k, requestInfo.getIdTransazione());
  1084.         }
  1085.         return k;
  1086.     }
  1087.     
  1088.     
  1089.     
  1090.     public static BYOKStore getBYOKStore(RequestInfo requestInfo, BYOKInstance instance) throws SecurityException{
  1091.         if(instance==null) {
  1092.             throw new SecurityException("Instance is null");
  1093.         }
  1094.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && instance!=null && instance.getKeyCache()!=null;
  1095.         if(useRequestInfo) {
  1096.             Object o = requestInfo.getRequestConfig().getBYOKStore(instance.getKeyCache());
  1097.             if(o instanceof BYOKStore) {
  1098.                 return (BYOKStore) o;
  1099.             }
  1100.         }
  1101.         BYOKStore k = null;
  1102.         if(GestoreKeystoreCache.cacheEnabled) {
  1103.             k = GestoreKeystoreCache.byokStoreCache.getKeystoreAndCreateIfNotExists(instance.getKeyCache(), instance);
  1104.         }else
  1105.             k = new BYOKStore(instance.getKeyCache(), instance);
  1106.         if(useRequestInfo) {
  1107.             requestInfo.getRequestConfig().addBYOKStore(instance.getKeyCache(), k, requestInfo.getIdTransazione());
  1108.         }
  1109.         return k;
  1110.     }
  1111.     
  1112.     
  1113.     
  1114.     public static CRLCertstore getCRLCertstore(RequestInfo requestInfo,String crlPath) throws SecurityException{
  1115.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && crlPath!=null;
  1116.         if(useRequestInfo) {
  1117.             Object o = requestInfo.getRequestConfig().getCRLCertstore(crlPath);
  1118.             if(o instanceof CRLCertstore) {
  1119.                 return (CRLCertstore) o;
  1120.             }
  1121.         }
  1122.         CRLCertstore k = null;
  1123.         if(GestoreKeystoreCache.cacheEnabled)
  1124.             k = GestoreKeystoreCache.crlCertstoreCache.getKeystoreAndCreateIfNotExists(crlPath);
  1125.         else
  1126.             k = new CRLCertstore(crlPath);
  1127.         if(useRequestInfo) {
  1128.             requestInfo.getRequestConfig().addCRLCertstore(crlPath, k, requestInfo.getIdTransazione());
  1129.         }
  1130.         return k;
  1131.     }
  1132.     public static CRLCertstore getCRLCertstore(RequestInfo requestInfo,String crlPath, Map<String, byte[]> localResources) throws SecurityException{
  1133.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && crlPath!=null;
  1134.         if(useRequestInfo) {
  1135.             Object o = requestInfo.getRequestConfig().getCRLCertstore(crlPath);
  1136.             if(o instanceof CRLCertstore) {
  1137.                 return (CRLCertstore) o;
  1138.             }
  1139.         }
  1140.         CRLCertstore k = null;
  1141.         if(GestoreKeystoreCache.cacheEnabled)
  1142.             k = GestoreKeystoreCache.crlCertstoreCache.getKeystoreAndCreateIfNotExists(crlPath, localResources);
  1143.         else
  1144.             k = new CRLCertstore(crlPath, localResources);
  1145.         if(useRequestInfo) {
  1146.             requestInfo.getRequestConfig().addCRLCertstore(crlPath, k, requestInfo.getIdTransazione());
  1147.         }
  1148.         return k;
  1149.     }
  1150.     
  1151.     public static SSLSocketFactory getSSLSocketFactory(RequestInfo requestInfo,SSLConfig sslConfig) throws SecurityException{
  1152.         String sslConfigKey = sslConfig.toString();
  1153.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && sslConfigKey!=null;
  1154.         if(useRequestInfo) {
  1155.             Object o = requestInfo.getRequestConfig().getSSLSocketFactory(sslConfigKey);
  1156.             if(o instanceof SSLSocketFactory) {
  1157.                 return (SSLSocketFactory) o;
  1158.             }
  1159.         }
  1160.         SSLSocketFactory k = null;
  1161.         if(GestoreKeystoreCache.cacheEnabled)
  1162.             k = GestoreKeystoreCache.sslSocketFactoryCache.getKeystoreAndCreateIfNotExists(sslConfigKey, requestInfo, sslConfig);
  1163.         else
  1164.             k = new SSLSocketFactory(requestInfo, sslConfig);
  1165.         if(useRequestInfo) {
  1166.             requestInfo.getRequestConfig().addSSLSocketFactory(sslConfigKey, k, requestInfo.getIdTransazione());
  1167.         }
  1168.         return k;   
  1169.     }
  1170.     
  1171.     public static ExternalResource getExternalResource(RequestInfo requestInfo,String resource, ExternalResourceConfig externalConfig) throws SecurityException{
  1172.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && resource!=null;
  1173.         if(useRequestInfo) {
  1174.             Object o = requestInfo.getRequestConfig().getExternalResource(resource);
  1175.             if(o instanceof ExternalResource) {
  1176.                 return (ExternalResource) o;
  1177.             }
  1178.         }
  1179.         ExternalResource k = null;
  1180.         if(GestoreKeystoreCache.cacheEnabled)
  1181.             k = GestoreKeystoreCache.externalResourceCache.getKeystoreAndCreateIfNotExists(resource, externalConfig); // gestito nell'oggetto ExternalResourceCache l'utilizzo della risorsa come id
  1182.         else
  1183.             k = new ExternalResource(resource, resource, externalConfig); // l'id della risorsa esterna รจ la url stessa della risorsa, non serve un id aggiuntivo
  1184.         if(useRequestInfo) {
  1185.             requestInfo.getRequestConfig().addExternalResource(resource, k, requestInfo.getIdTransazione());
  1186.         }
  1187.         return k;
  1188.     }
  1189.     
  1190.     public static SSLConfigProps getSSLConfigProps(RequestInfo requestInfo,String resource, boolean sslConfigRequired) throws SecurityException{
  1191.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null && resource!=null;
  1192.         if(useRequestInfo) {
  1193.             Object o = requestInfo.getRequestConfig().getSSLConfigProps(resource);
  1194.             if(o instanceof SSLConfigProps) {
  1195.                 return (SSLConfigProps) o;
  1196.             }
  1197.         }
  1198.         SSLConfigProps k = null;
  1199.         if(GestoreKeystoreCache.cacheEnabled)
  1200.             k = GestoreKeystoreCache.sslConfigPropsCache.getKeystoreAndCreateIfNotExists(resource, sslConfigRequired);
  1201.         else
  1202.             k = new SSLConfigProps(resource, sslConfigRequired);
  1203.         if(useRequestInfo) {
  1204.             requestInfo.getRequestConfig().addSSLConfigProps(resource, k, requestInfo.getIdTransazione());
  1205.         }
  1206.         return k;
  1207.     }
  1208.     
  1209.     public static OCSPResponse getOCSPResponse(RequestInfo requestInfo,IOCSPValidator ocspValidator, X509Certificate cert) throws SecurityException{
  1210.         if(cert==null) {
  1211.             throw new SecurityException("Certificate is null");
  1212.         }
  1213.         CertificateInfo certInfo = new CertificateInfo(cert, "cer");
  1214.         return getOCSPResponse(requestInfo, ocspValidator, certInfo);
  1215.     }
  1216.     public static OCSPResponse getOCSPResponse(RequestInfo requestInfo,IOCSPValidator ocspValidator, CertificateInfo cert) throws SecurityException{
  1217.         if(cert==null) {
  1218.             throw new SecurityException("Certificate is null");
  1219.         }
  1220.         String pem = null;
  1221.         try {
  1222.             pem = cert.getPEMEncoded();
  1223.         }catch(Exception t) {
  1224.             throw new SecurityException(t.getMessage(),t);
  1225.         }
  1226.         if(pem==null) {
  1227.             throw new SecurityException("Certificate PEM Encoding is null");
  1228.         }
  1229.         boolean useRequestInfo = requestInfo!=null && requestInfo.getRequestConfig()!=null;
  1230.         if(useRequestInfo) {
  1231.             Object o = requestInfo.getRequestConfig().getOCSPResponse(pem);
  1232.             if(o instanceof OCSPResponse) {
  1233.                 return (OCSPResponse) o;
  1234.             }
  1235.         }
  1236.         OCSPResponse k = null;
  1237.         if(GestoreKeystoreCache.cacheEnabled)
  1238.             k = GestoreKeystoreCache.ocspResponseCache.getKeystoreAndCreateIfNotExists(pem, ocspValidator, cert.getCertificate());
  1239.         else
  1240.             k = new OCSPResponse(ocspValidator, cert.getCertificate()); 
  1241.         if(useRequestInfo) {
  1242.             requestInfo.getRequestConfig().addOCSPResponse(pem, k, requestInfo.getIdTransazione());
  1243.         }
  1244.         return k;
  1245.     }
  1246. }
Created with JaCoCo 0.8.8.202204050719