GestoreKeystoreCaching.java

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

  22. import java.security.cert.X509Certificate;
  23. import java.util.Map;

  25. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  26. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  27. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  28. import org.openspcoop2.security.SecurityException;
  29. import org.openspcoop2.security.keystore.CRLCertstore;
  30. import org.openspcoop2.security.keystore.ExternalResource;
  31. import org.openspcoop2.security.keystore.HttpStore;
  32. import org.openspcoop2.security.keystore.JWKSetStore;
  33. import org.openspcoop2.security.keystore.KeyPairStore;
  34. import org.openspcoop2.security.keystore.MerlinKeystore;
  35. import org.openspcoop2.security.keystore.MerlinTruststore;
  36. import org.openspcoop2.security.keystore.MultiKeystore;
  37. import org.openspcoop2.security.keystore.OCSPResponse;
  38. import org.openspcoop2.security.keystore.PublicKeyStore;
  39. import org.openspcoop2.security.keystore.RemoteStore;
  40. import org.openspcoop2.security.keystore.SSLConfigProps;
  41. import org.openspcoop2.security.keystore.SSLSocketFactory;
  42. import org.openspcoop2.security.keystore.SecretKeyStore;
  43. import org.openspcoop2.security.keystore.SymmetricKeystore;
  44. import org.openspcoop2.utils.Utilities;
  45. import org.openspcoop2.utils.cache.Cache;
  46. import org.openspcoop2.utils.cache.CacheAlgorithm;
  47. import org.openspcoop2.utils.cache.CacheType;
  48. import org.openspcoop2.utils.cache.Constants;
  49. import org.openspcoop2.utils.certificate.CertificateInfo;
  50. import org.openspcoop2.utils.certificate.remote.IRemoteStoreProvider;
  51. import org.openspcoop2.utils.certificate.remote.RemoteKeyType;
  52. import org.openspcoop2.utils.certificate.remote.RemoteStoreClientInfo;
  53. import org.openspcoop2.utils.certificate.remote.RemoteStoreConfig;
  54. import org.openspcoop2.utils.transport.http.ExternalResourceConfig;
  55. import org.openspcoop2.utils.transport.http.IOCSPValidator;
  56. import org.openspcoop2.utils.transport.http.SSLConfig;
  57. import org.slf4j.Logger;

  59. /**     
  60.  * GestoreCacheKeystore
  61.  *
  62.  * @author Poli Andrea (poli@link.it)
  63.  * @author $Author$
  64.  * @version $Rev$, $Date$
  65.  */
  66. public class GestoreKeystoreCaching {

  68.     /** Chiave della cache */
  69.     private static final String KEYSTORE_CACHE_NAME = "keystore";
  70.     /** Cache */
  71.     private static Cache cache = null;

  73.     
  74.     private static KeystoreException newKeystoreExceptionGenericError(Exception e) {
  75.         return new KeystoreException("Abilitazione cache per i dati contenenti i keystore non riuscita: "+e.getMessage(),e);
  76.     }

  78.     /* --------------- Cache --------------------*/
  79.     public static boolean isCacheAbilitata() {
  80.         return cache!=null;
  81.     }
  82.     public static void resetCache() throws KeystoreException{
  83.         try{
  84.             if(cache!=null){
  85.                 cache.clear();
  86.             }
  87.         }catch(Exception e){
  88.             throw new KeystoreException("Reset della cache per i dati contenenti i keystore non riuscita: "+e.getMessage(),e);
  89.         }
  90.     }
  91.     public static String printStatsCache(String separator) throws KeystoreException{
  92.         try{
  93.             if(cache!=null){
  94.                 return getStatsCache(separator);
  95.             }else{
  96.                 throw new KeystoreException(Constants.MSG_CACHE_NON_ABILITATA);
  97.             }
  98.         }catch(Exception e){
  99.             throw new KeystoreException("Visualizzazione Statistiche riguardante la cache per i dati contenenti i keystore non riuscita: "+e.getMessage(),e);
  100.         }
  101.     }
  102.     private static String getStatsCache(String separator) throws KeystoreException {
  103.         try{
  104.             String stats = cache.printStats(separator);
  105.             String lifeTimeLabel = "LifeTime:";
  106.             if(stats.contains(lifeTimeLabel)) {
  107.                 
  108.                 StringBuilder bf = new StringBuilder();
  109.                 bf.append("CRLsLifeTime:");
  110.                 long lifeTime = GestoreKeystoreCaching.getItemCrlLifeSecond();
  111.                 if(lifeTime>0){
  112.                     bf.append(Utilities.convertSystemTimeIntoStringMillisecondi(lifeTime*1000,false));
  113.                 }
  114.                 else if(lifeTime==0){
  115.                     bf.append("0");
  116.                 }
  117.                 else if(lifeTime<0){
  118.                     bf.append("Infinito");
  119.                 }
  120.                 bf.append(separator);
  121.             
  122.                 return stats.replace(lifeTimeLabel, bf.toString() + lifeTimeLabel);
  123.             }
  124.             else {
  125.                 return stats;
  126.             }
  127.         }catch(Exception e){
  128.             throw new KeystoreException(e.getMessage(),e);
  129.         }
  130.     }
  131.     public static void abilitaCache() throws KeystoreException{
  132.         try{
  133.             if(cache!=null)
  134.                 throw new KeystoreException("Cache gia' abilitata");
  135.             else{
  136.                 abilitaCacheEngine();
  137.             }
  138.         }catch(Exception e){
  139.             throw newKeystoreExceptionGenericError(e);
  140.         }
  141.     }
  142.     private static synchronized void abilitaCacheEngine() throws KeystoreException{
  143.         try{
  144.             if(cache==null) {
  145.                 cache = new Cache(CacheType.JCS, KEYSTORE_CACHE_NAME); // lascio JCS come default abilitato via jmx
  146.                 cache.build();
  147.             }
  148.         }catch(Exception e){
  149.             throw newKeystoreExceptionGenericError(e);
  150.         }
  151.     }
  152.     public static void abilitaCache(Long dimensioneCache,Boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond, Logger log) throws KeystoreException{
  153.         try{
  154.             if(cache!=null)
  155.                 throw new KeystoreException("Cache gia' abilitata");
  156.             else{
  157.                 int dimensione = -1;
  158.                 if(dimensioneCache!=null){
  159.                     dimensione = dimensioneCache.intValue();
  160.                 }
  161.                 initCache(CacheType.JCS, dimensione, algoritmoCacheLRU, itemIdleTime, itemLifeSecond, log); // lascio JCS come default abilitato via jmx
  162.             }
  163.         }catch(Exception e){
  164.             throw newKeystoreExceptionGenericError(e);
  165.         }
  166.     }
  167.     public static void disabilitaCache() throws KeystoreException{
  168.         try{
  169.             if(cache==null)
  170.                 throw new KeystoreException("Cache gia' disabilitata");
  171.             else{
  172.                 disabilitaCacheEngine();
  173.             }
  174.         }catch(Exception e){
  175.             throw new KeystoreException("Disabilitazione cache per i dati contenenti i keystore non riuscita: "+e.getMessage(),e);
  176.         }
  177.     }   
  178.     private static synchronized void disabilitaCacheEngine() throws KeystoreException{
  179.         try{
  180.             if(cache!=null) {
  181.                 cache.clear();
  182.                 cache = null;
  183.             }
  184.         }catch(Exception e){
  185.             throw new KeystoreException("Disabilitazione cache per i dati contenenti i keystore non riuscita: "+e.getMessage(),e);
  186.         }
  187.     }   
  188.     public static String listKeysCache(String separator) throws KeystoreException{
  189.         try{
  190.             if(cache!=null){
  191.                 return getKeysCache(separator);
  192.             }else{
  193.                 throw new KeystoreException(Constants.MSG_CACHE_NON_ABILITATA);
  194.             }
  195.         }catch(Exception e){
  196.             throw new KeystoreException("Visualizzazione chiavi presenti nella cache per i dati contenenti i keystore non riuscita: "+e.getMessage(),e);
  197.         }
  198.     }
  199.     private static String getKeysCache(String separator) throws KeystoreException {
  200.         try{
  201.             return cache.printKeys(separator);
  202.         }catch(Exception e){
  203.             throw new KeystoreException(e.getMessage(),e);
  204.         }
  205.     }
  206.     
  207.     public static String getObjectCache(String key) throws KeystoreException{
  208.         try{
  209.             if(cache!=null){
  210.                 return getByKey(key);
  211.             }else{
  212.                 throw new KeystoreException(Constants.MSG_CACHE_NON_ABILITATA);
  213.             }
  214.         }catch(Exception e){
  215.             throw new KeystoreException("Visualizzazione oggetto presente nella cache per i dati contenenti i keystore non riuscita: "+e.getMessage(),e);
  216.         }
  217.     }
  218.     private static String getByKey(String key) throws KeystoreException {
  219.         try{
  220.             Object o = cache.get(key);
  221.             if(o!=null){
  222.                 return o.toString();
  223.             }else{
  224.                 return "oggetto con chiave ["+key+"] non presente";
  225.             }
  226.         }catch(Exception e){
  227.             throw new KeystoreException(e.getMessage(),e);
  228.         }
  229.     }
  230.     
  231.     public static void removeObjectCache(String key) throws KeystoreException{
  232.         try{
  233.             if(cache!=null){
  234.                 removeByKey(key);
  235.             }else{
  236.                 throw new KeystoreException(Constants.MSG_CACHE_NON_ABILITATA);
  237.             }
  238.         }catch(Exception e){
  239.             throw new KeystoreException("Rimozione oggetto presente nella cache per i dati contenenti i keystore non riuscita: "+e.getMessage(),e);
  240.         }
  241.     }
  242.     private static void removeByKey(String key) throws KeystoreException {
  243.         try{
  244.             cache.remove(key);
  245.         }catch(Exception e){
  246.             throw new KeystoreException(e.getMessage(),e);
  247.         }
  248.     }
  249.     

  251.     /*----------------- INIZIALIZZAZIONE --------------------*/

  253.     public static void initialize(Logger log) throws KeystoreException{
  254.         GestoreKeystoreCaching.initialize(null, false, -1,null,-1l,-1l, log);
  255.     }
  256.     public static void initialize(CacheType cacheType, int dimensioneCache,String algoritmoCache,
  257.             long idleTime, long itemLifeSecond, Logger log) throws KeystoreException{
  258.         GestoreKeystoreCaching.initialize(cacheType, true, dimensioneCache,algoritmoCache,idleTime,itemLifeSecond, log);
  259.     }

  261.     private static void initialize(CacheType cacheType, boolean cacheAbilitata,int dimensioneCache,String algoritmoCache,
  262.             long idleTime, long itemLifeSecond, Logger log) throws KeystoreException{

  264.         // Inizializzazione Cache
  265.         if(cacheAbilitata){
  266.             GestoreKeystoreCaching.initCache(cacheType, dimensioneCache, algoritmoCache, idleTime, itemLifeSecond, log);
  267.         }

  269.     }
  270.     private static void initCache(CacheType cacheType, Integer dimensioneCache,String algoritmoCache,Long itemIdleTime,Long itemLifeSecond,Logger alog) throws KeystoreException{
  271.         initCache(cacheType, dimensioneCache, CostantiConfigurazione.CACHE_LRU.toString().equalsIgnoreCase(algoritmoCache), itemIdleTime, itemLifeSecond, alog);
  272.     }
  273.     
  274.     private static void initCache(CacheType cacheType, Integer dimensioneCache,boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond,Logger alog) throws KeystoreException{
  275.         
  276.         try {
  277.             cache = new Cache(cacheType, KEYSTORE_CACHE_NAME);
  278.         }catch(Exception e) {
  279.             throw new KeystoreException(e.getMessage(),e);
  280.         }
  281.     
  282.         // dimensione
  283.         initCacheSize(dimensioneCache, alog);
  284.         
  285.         // algoritno
  286.         String msg = "Algoritmo di cache (ResponseCaching) impostato al valore: LRU";
  287.         if(!algoritmoCacheLRU){
  288.             msg = "Algoritmo di cache (ResponseCaching) impostato al valore: MRU";
  289.         }
  290.         alog.info(msg);
  291.         if(!algoritmoCacheLRU)
  292.             cache.setCacheAlgoritm(CacheAlgorithm.MRU);
  293.         else
  294.             cache.setCacheAlgoritm(CacheAlgorithm.LRU);
  295.         
  296.         
  297.         // idle time
  298.         if(itemIdleTime!=null && itemIdleTime>0){
  299.             try{
  300.                 msg = "Attributo 'IdleTime' (ResponseCaching) impostato al valore: "+itemIdleTime;
  301.                 alog.info(msg);
  302.                 cache.setItemIdleTime(itemIdleTime);
  303.             }catch(Exception error){
  304.                 msg = "Parametro errato per l'attributo 'IdleTime' (ResponseCaching): "+error.getMessage();
  305.                 alog.error(msg);
  306.                 throw new KeystoreException(msg,error);
  307.             }
  308.         }
  309.         
  310.         // LifeSecond
  311.         long longItemLife = -1; 
  312.         if(itemLifeSecond!=null && itemLifeSecond>0){
  313.             longItemLife = itemLifeSecond.longValue();
  314.         }
  315.         try{
  316.             msg = "Attributo 'MaxLifeSecond' (ResponseCaching) impostato al valore: "+longItemLife;
  317.             alog.info(msg);
  318.             cache.setItemLifeTime(longItemLife);
  319.         }catch(Exception error){
  320.             msg = "Parametro errato per l'attributo 'MaxLifeSecond' (ResponseCaching): "+error.getMessage();
  321.             alog.error(msg);
  322.             throw new KeystoreException(msg,error);
  323.         }
  324.         
  325.         try {
  326.             cache.build();
  327.         }catch(Exception e) {
  328.             throw new KeystoreException(e.getMessage(),e);
  329.         }
  330.         
  331.         // impostazione di JCS nel gestore delle cache dei keystore 
  332.         
  333.         org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.setKeystoreCacheJCS(true, longItemLife>0 ? (int)longItemLife : 7200, cache);
  334.     }
  335.     
  336.     private static void initCacheSize(Integer dimensioneCache, Logger alog) throws KeystoreException {
  337.         // dimensione
  338.         if(dimensioneCache!=null && dimensioneCache>0){
  339.             try{
  340.                 String msg = "Dimensione della cache (ResponseCaching) impostata al valore: "+dimensioneCache;
  341.                 alog.info(msg);
  342.                 cache.setCacheSize(dimensioneCache);
  343.             }catch(Exception error){
  344.                 String msg = "Parametro errato per la dimensione della cache (ResponseCaching): "+error.getMessage();
  345.                 alog.error(msg);
  346.                 throw new KeystoreException(msg,error);
  347.             }
  348.         }
  349.     }
  350.     

  352.     
  353.     
  354.     private static long itemCrlLifeSecond; 
  355.     public static void setCacheCrlLifeSeconds(long itemCrlLifeSecondParam) {
  356.         itemCrlLifeSecond = itemCrlLifeSecondParam;
  357.         org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.setKeystoreCacheJCSCrlLifeSeconds(itemCrlLifeSecond>0 ? (int)itemCrlLifeSecond : 7200);
  358.     }
  359.     public static long getItemCrlLifeSecond() {
  360.         return itemCrlLifeSecond;
  361.     }
  362.     
  363.     
  364.     private static GestoreKeystoreCaching staticInstance = null;
  365.     public static synchronized void initialize() throws KeystoreException{
  366.         if(staticInstance==null){
  367.             staticInstance = new GestoreKeystoreCaching();
  368.         }
  369.     }
  370.     public static GestoreKeystoreCaching getInstance() throws KeystoreException{
  371.         if(staticInstance==null){
  372.             // spotbugs warning 'SING_SINGLETON_GETTER_NOT_SYNCHRONIZED': l'istanza viene creata allo startup
  373.             synchronized (GestoreKeystoreCaching.class) {
  374.                 throw new KeystoreException("GestoreKeystore non inizializzato");
  375.             }
  376.         }
  377.         return staticInstance;
  378.     }
  379.     
  380.     @SuppressWarnings("unused")
  381.     private Logger log;
  382.     
  383.     private GestoreKeystoreCaching() throws KeystoreException{
  384.         this.log = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  385.     }
  386.     
  387.     
  388.     
  389.     
  390.     
  391.     
  392.     
  393.     
  394.     
  395.     /* ********************** ENGINE ************************** */
  396.     
  397.     public static MerlinTruststore getMerlinTruststore(RequestInfo requestInfo, String propertyFilePath) throws SecurityException{
  398.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getMerlinTruststore(requestInfo, propertyFilePath);
  399.     }
  400.     public static MerlinTruststore getMerlinTruststore(RequestInfo requestInfo, String pathStore,String tipoStore,String passwordStore) throws SecurityException{
  401.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getMerlinTruststore(requestInfo, pathStore, tipoStore, passwordStore);
  402.     }
  403.     public static MerlinTruststore getMerlinTruststore(RequestInfo requestInfo, byte[] bytesStore,String tipoStore,String passwordStore) throws SecurityException{
  404.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getMerlinTruststore(requestInfo, bytesStore, tipoStore, passwordStore);
  405.     }
  406.     
  407.     
  408.     public static MerlinKeystore getMerlinKeystore(RequestInfo requestInfo, String propertyFilePath) throws SecurityException{
  409.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getMerlinKeystore(requestInfo, propertyFilePath);
  410.     }
  411.     public static MerlinKeystore getMerlinKeystore(RequestInfo requestInfo, String propertyFilePath,String passwordPrivateKey) throws SecurityException{
  412.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getMerlinKeystore(requestInfo, propertyFilePath, passwordPrivateKey);
  413.     }
  414.     public static MerlinKeystore getMerlinKeystore(RequestInfo requestInfo, String pathStore,String tipoStore,String passwordStore) throws SecurityException{
  415.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getMerlinKeystore(requestInfo, pathStore, tipoStore, passwordStore);
  416.     }
  417.     public static MerlinKeystore getMerlinKeystore(RequestInfo requestInfo, String pathStore,String tipoStore,String passwordStore,String passwordPrivateKey) throws SecurityException{
  418.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getMerlinKeystore(requestInfo, pathStore, tipoStore, passwordStore, passwordPrivateKey);
  419.     }
  420.     public static MerlinKeystore getMerlinKeystore(RequestInfo requestInfo, byte[] bytesStore,String tipoStore,String passwordStore) throws SecurityException{
  421.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getMerlinKeystore(requestInfo, bytesStore, tipoStore, passwordStore);
  422.     }
  423.     public static MerlinKeystore getMerlinKeystore(RequestInfo requestInfo,byte[] bytesStore,String tipoStore,String passwordStore,String passwordPrivateKey) throws SecurityException{
  424.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getMerlinKeystore(requestInfo, bytesStore, tipoStore, passwordStore, passwordPrivateKey);
  425.     }
  426.     
  427.     
  428.     public static SymmetricKeystore getSymmetricKeystore(RequestInfo requestInfo, String alias,String key,String algoritmo) throws SecurityException{
  429.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getSymmetricKeystore(requestInfo, key, alias, algoritmo);
  430.     }
  431.     
  432.     
  433.     public static MultiKeystore getMultiKeystore(RequestInfo requestInfo, String propertyFilePath) throws SecurityException{
  434.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getMultiKeystore(requestInfo, propertyFilePath);
  435.     }
  436.     
  437.     
  438.     public static JWKSetStore getJwkSetStore(RequestInfo requestInfo, String propertyFilePath) throws SecurityException{
  439.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getJwkSetStore(requestInfo, propertyFilePath);
  440.     }
  441.     public static JWKSetStore getJwkSetStore(RequestInfo requestInfo, byte[] archive) throws SecurityException{
  442.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getJwkSetStore(requestInfo, archive);
  443.     }
  444.     
  445.     
  446.     public static KeyPairStore getKeyPairStore(RequestInfo requestInfo, String privateKeyPath, String publicKeyPath, String privateKeyPassword, String algorithm) throws SecurityException{
  447.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getKeyPairStore(requestInfo, privateKeyPath, publicKeyPath, privateKeyPassword, algorithm);
  448.     }
  449.     public static KeyPairStore getKeyPairStore(RequestInfo requestInfo, byte[] privateKey, byte[] publicKey, String privateKeyPassword, String algorithm) throws SecurityException{
  450.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getKeyPairStore(requestInfo, privateKey, publicKey, privateKeyPassword, algorithm);
  451.     }
  452.     
  453.     
  454.     public static PublicKeyStore getPublicKeyStore(RequestInfo requestInfo, String publicKeyPath, String algorithm) throws SecurityException{
  455.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getPublicKeyStore(requestInfo, publicKeyPath, algorithm);
  456.     }
  457.     public static PublicKeyStore getPublicKeyStore(RequestInfo requestInfo, byte[] publicKey, String algorithm) throws SecurityException{
  458.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getPublicKeyStore(requestInfo, publicKey, algorithm);
  459.     }
  460.     
  461.     
  462.     public static SecretKeyStore getSecretKeyStore(RequestInfo requestInfo, String secretKeyPath, String algorithm) throws SecurityException{
  463.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getSecretKeyStore(requestInfo, secretKeyPath, algorithm);
  464.     }
  465.     public static SecretKeyStore getSecretKeyStore(RequestInfo requestInfo, byte[] secretKey, String algorithm) throws SecurityException{
  466.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getSecretKeyStore(requestInfo, secretKey, algorithm);
  467.     }
  468.     
  469.     
  470.     public static RemoteStore getRemoteStore(RequestInfo requestInfo, String keyId, RemoteKeyType keyType, RemoteStoreConfig remoteStoreConfig, IRemoteStoreProvider provider) throws SecurityException{
  471.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getRemoteStore(requestInfo, keyId, keyType, remoteStoreConfig, provider);
  472.     }
  473.     public static void removeRemoteStore(RequestInfo requestInfo, String keyId, RemoteKeyType keyType, RemoteStoreConfig remoteStoreConfig) throws SecurityException{
  474.         org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.removeRemoteStore(requestInfo, keyId, keyType, remoteStoreConfig);
  475.     }
  476.     
  477.     public static RemoteStoreClientInfo getRemoteStoreClientInfo(RequestInfo requestInfo, String keyId, String clientId, RemoteStoreConfig remoteStoreConfig, IRemoteStoreProvider provider,
  478.             org.openspcoop2.utils.Map<Object> context) throws SecurityException{
  479.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getRemoteStoreClientInfo(requestInfo, keyId, clientId, remoteStoreConfig, provider,
  480.                 context);
  481.     }
  482.     public static void removeRemoteStoreClientInfo(RequestInfo requestInfo, String keyId, RemoteStoreConfig remoteStoreConfig) throws SecurityException{
  483.         org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.removeRemoteStoreClientInfo(requestInfo, keyId, remoteStoreConfig);
  484.     }
  485.     
  486.     public static HttpStore getHttpStore(RequestInfo requestInfo, String endpoint) throws SecurityException{
  487.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getHttpStore(requestInfo, endpoint);
  488.     }
  489.     public static HttpStore getHttpStore(RequestInfo requestInfo, String endpoint, Integer connectionTimeout, Integer readTimeout) throws SecurityException{
  490.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getHttpStore(requestInfo, endpoint, connectionTimeout, readTimeout);
  491.     }
  492.     public static HttpStore getHttpStore(RequestInfo requestInfo, String endpoint, MerlinTruststore trustStoreSsl) throws SecurityException{
  493.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getHttpStore(requestInfo, endpoint, trustStoreSsl);
  494.     }
  495.     public static HttpStore getHttpStore(RequestInfo requestInfo, String endpoint, MerlinTruststore trustStoreSsl, CRLCertstore crlTrustStoreSsl) throws SecurityException{
  496.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getHttpStore(requestInfo, endpoint, trustStoreSsl, crlTrustStoreSsl);
  497.     }
  498.     public static HttpStore getHttpStore(RequestInfo requestInfo, String endpoint, 
  499.             Integer connectionTimeout, Integer readTimeout,
  500.             MerlinTruststore trustStoreSsl) throws SecurityException{
  501.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getHttpStore(requestInfo, endpoint,
  502.                 connectionTimeout, readTimeout, 
  503.                 trustStoreSsl);
  504.     }
  505.     public static HttpStore getHttpStore(RequestInfo requestInfo,String endpoint, 
  506.             Integer connectionTimeout, Integer readTimeout,
  507.             MerlinTruststore trustStoreSsl, CRLCertstore crlTrustStoreSsl) throws SecurityException{
  508.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getHttpStore(requestInfo, endpoint,
  509.                 connectionTimeout, readTimeout, 
  510.                 trustStoreSsl, crlTrustStoreSsl);
  511.     }
  512.     
  513.     
  514.     public static CRLCertstore getCRLCertstore(RequestInfo requestInfo,String crlPath) throws SecurityException{
  515.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getCRLCertstore(requestInfo,crlPath);
  516.     }
  517.     public static CRLCertstore getCRLCertstore(RequestInfo requestInfo,String crlPath, Map<String, byte[]> localResources) throws SecurityException{
  518.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getCRLCertstore(requestInfo,crlPath,localResources);
  519.     }
  520.     
  521.     
  522.     public static SSLSocketFactory getSSLSocketFactory(RequestInfo requestInfo,SSLConfig sslConfig) throws SecurityException{
  523.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getSSLSocketFactory(requestInfo,sslConfig);
  524.     }
  525.     
  526.     
  527.     public static ExternalResource getExternalResource(RequestInfo requestInfo,String resource, ExternalResourceConfig externalConfig) throws SecurityException{
  528.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getExternalResource(requestInfo, resource, externalConfig);
  529.     }
  530.     
  531.     
  532.     public static SSLConfigProps getSSLConfigProps(RequestInfo requestInfo,String resource, boolean sslConfigRequired) throws SecurityException{
  533.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getSSLConfigProps(requestInfo, resource, sslConfigRequired);
  534.     }
  535.     
  536.     
  537.     public static OCSPResponse getOCSPResponse(RequestInfo requestInfo,IOCSPValidator ocspValidator, X509Certificate cert) throws SecurityException{
  538.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getOCSPResponse(requestInfo, ocspValidator, cert);
  539.     }
  540.     public static OCSPResponse getOCSPResponse(RequestInfo requestInfo,IOCSPValidator ocspValidator, CertificateInfo cert) throws SecurityException{
  541.         return org.openspcoop2.security.keystore.cache.GestoreKeystoreCache.getOCSPResponse(requestInfo, ocspValidator, cert);
  542.     }
  543. }
Created with JaCoCo 0.8.8.202204050719