OCSPManager.java

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

  21. package org.openspcoop2.utils.certificate.ocsp;

  23. import java.io.File;
  24. import java.io.FileInputStream;
  25. import java.io.InputStream;
  26. import java.util.ArrayList;
  27. import java.util.Collections;
  28. import java.util.Enumeration;
  29. import java.util.HashMap;
  30. import java.util.List;
  31. import java.util.Map;
  32. import java.util.Properties;

  34. import org.openspcoop2.utils.SortedMap;
  35. import org.openspcoop2.utils.UtilsException;
  36. import org.openspcoop2.utils.properties.PropertiesReader;
  37. import org.slf4j.Logger;

  39. /**
  40.  * OCSPManager
  41.  *
  42.  * @author Poli Andrea (apoli@link.it)
  43.  * @author $Author$
  44.  * @version $Rev$, $Date$
  45.  */
  46. public class OCSPManager {

  48.     private static OCSPManager staticInstance;
  49.     public static synchronized void init(File f, boolean throwNotExists, boolean loadDefault, Logger log) throws UtilsException {
  50.         if(staticInstance==null) {
  51.             staticInstance = new OCSPManager(f, throwNotExists, loadDefault, log);
  52.         }
  53.     }
  54.     public static OCSPManager getInstance() {
  55.         // spotbugs warning 'SING_SINGLETON_GETTER_NOT_SYNCHRONIZED': l'istanza viene creata allo startup
  56.         if (staticInstance == null) {
  57.             synchronized (OCSPManager.class) {
  58.                 if (staticInstance == null) {
  59.                     return null;
  60.                 }
  61.             }
  62.         }
  63.         return staticInstance;
  64.     }
  65.     
  66.     private HashMap<String, OCSPConfig> hsmOCSPConfigMapIDtoConfig = new HashMap<>();
  67.     
  68.     private HashMap<String, String> hsmOCSPConfigMapTypeToID = new HashMap<>();
  69.     private HashMap<String, String> hsmOCSPConfigMapLabelToID = new HashMap<>();
  70.     
  71.     private SortedMap<String> hsmOCSPConfigSortedMapTypeLabel = new SortedMap<>();
  72.     
  73.     private OCSPManager(File f, boolean throwNotExists, boolean loadDefault, Logger log) throws UtilsException {
  74.         if(!f.exists()) {
  75.             if(throwNotExists) {
  76.                 throw new UtilsException("File '"+f.getAbsolutePath()+"' not exists");
  77.             }
  78.             else {
  79.                 if(loadDefault) {
  80.                     try {
  81.                         try(InputStream isDefault = OCSPManager.class.getResourceAsStream("/org/openspcoop2/utils/certificate/ocsp/default.properties")){
  82.                             if(isDefault!=null) {
  83.                                 Properties p = new Properties();
  84.                                 try {
  85.                                     p.load(isDefault);
  86.                                 }catch(Exception t) {
  87.                                     throw new UtilsException("File '"+f.getAbsolutePath()+"'; initialize error: "+t.getMessage(),t);
  88.                                 }
  89.                                 init(p, log);
  90.                             }
  91.                         }
  92.                     }catch(Exception t) {
  93.                         throw new UtilsException("Default configuration; initialize error: "+t.getMessage(),t);
  94.                     }
  95.                 }
  96.             }
  97.         }
  98.         else {
  99.             if(!f.canRead()) {
  100.                 throw new UtilsException("File '"+f.getAbsolutePath()+"' cannot read");
  101.             }
  102.             Properties p = new Properties();
  103.             try {
  104.                 try(FileInputStream fin = new FileInputStream(f)){
  105.                     p.load(fin);
  106.                 }
  107.             }catch(Exception t) {
  108.                 throw new UtilsException("File '"+f.getAbsolutePath()+"'; initialize error: "+t.getMessage(),t);
  109.             }
  110.             init(p, log);
  111.         }
  112.     }
  113.     /**private OCSPManager(Properties p, Logger log) throws UtilsException {
  114.         init(p, log);
  115.     }*/
  116.     private void init(Properties p, Logger log) throws UtilsException {
  117.         
  118.         List<String> idKeystore = new ArrayList<>();
  119.         
  120.         if(p!=null && !p.isEmpty()) {
  121.             
  122.             Enumeration<?> enKeys = p.keys();
  123.             while (enKeys.hasMoreElements()) {
  124.                 Object object = enKeys.nextElement();
  125.                 if(object instanceof String) {
  126.                     String key = (String) object;
  127.                     
  128.                     if(key.startsWith(OCSPCostanti.PROPERTY_PREFIX) && key.length()>(OCSPCostanti.PROPERTY_PREFIX.length())) {
  129.                         String tmp = key.substring(OCSPCostanti.PROPERTY_PREFIX.length());
  130.                         if(tmp!=null && tmp.contains(".")) {
  131.                             int indeoOf = tmp.indexOf(".");
  132.                             if(indeoOf>0) {
  133.                                 String idK = tmp.substring(0,indeoOf);
  134.                                 if(!idKeystore.contains(idK)) {
  135.                                     idKeystore.add(idK);
  136.                                 }
  137.                             }
  138.                         }
  139.                     }
  140.                 }
  141.             }
  142.             
  143.         }
  144.         
  145.         if(!idKeystore.isEmpty()) {
  146.             
  147.             List<String> types = new ArrayList<>();
  148.             List<String> labels = new ArrayList<>();
  149.             
  150.             for (String idK : idKeystore) {
  151.                 String prefix = OCSPCostanti.PROPERTY_PREFIX + idK + ".";
  152.                 PropertiesReader pReader = new PropertiesReader(p, true);
  153.                 Properties pKeystore = pReader.readProperties_convertEnvProperties(prefix);
  154.                 OCSPConfig ocspConfig = new OCSPConfig(idK, pKeystore, log);
  155.                 
  156.                 // type (value è id del ocsp.properties)
  157.                 boolean alreadyExists = false;
  158.                 for (String type : this.hsmOCSPConfigMapTypeToID.keySet()) {
  159.                     if(ocspConfig.getType().equalsIgnoreCase(type)) {
  160.                         alreadyExists = true;
  161.                     }
  162.                 }
  163.                 if(alreadyExists) {
  164.                     throw new UtilsException("Same ocsp type found for responder '"+this.hsmOCSPConfigMapTypeToID.get(ocspConfig.getType())+"' e '"+idK+"'");
  165.                 }
  166.                 this.hsmOCSPConfigMapTypeToID.put(ocspConfig.getType(), idK);
  167.                 
  168.                 // label (value è id del ocsp.properties)
  169.                 alreadyExists = false;
  170.                 for (String label : this.hsmOCSPConfigMapLabelToID.keySet()) {
  171.                     if(ocspConfig.getLabel().equalsIgnoreCase(label)) {
  172.                         alreadyExists = true;
  173.                     }
  174.                 }
  175.                 if(alreadyExists) {
  176.                     throw new UtilsException("Same ocsp label found for responder '"+this.hsmOCSPConfigMapLabelToID.get(ocspConfig.getLabel())+"' e '"+idK+"'");
  177.                 }
  178.                 this.hsmOCSPConfigMapLabelToID.put(ocspConfig.getLabel(), idK);
  179.                 
  180.                 // id di ocsp.properties to config
  181.                 this.hsmOCSPConfigMapIDtoConfig.put(idK, ocspConfig);
  182.                             
  183.                 String msg = "OCSP config "+idK+" registrato (OCSP Type:"+ocspConfig.getType()+")";
  184.                 log.info(msg);
  185.                 
  186.                 types.add(ocspConfig.getType());
  187.                 labels.add(ocspConfig.getLabel());
  188.             }
  189.             
  190.             // SortedMap by label
  191.             Map<String, String> m = new HashMap<>();
  192.             for (int i = 0; i < types.size(); i++) {
  193.                 String type = types.get(i);
  194.                 String label = labels.get(i);
  195.                 m.put(label, type);
  196.             }
  197.             Collections.sort(labels);
  198.             for (String l : labels) {
  199.                 this.hsmOCSPConfigSortedMapTypeLabel.add(m.get(l), l);  
  200.             }
  201.         }
  202.         else {
  203.             log.warn("La configurazione fornita per HSM non contiene alcun keystore");
  204.         }
  205.     }
  206.     
  207.     public OCSPConfig getOCSPConfig(String ocspConfigType) throws UtilsException {
  208.         if(!this.hsmOCSPConfigMapTypeToID.containsKey(ocspConfigType)) {
  209.             throw new UtilsException("OCSP config type '"+ocspConfigType+"' unknown");
  210.         }
  211.         String idK = this.hsmOCSPConfigMapTypeToID.get(ocspConfigType);
  212.         if(!this.hsmOCSPConfigMapIDtoConfig.containsKey(idK)) {
  213.             throw new UtilsException("OCSP config type '"+ocspConfigType+"' unknown ? (id:"+idK+")");
  214.         }
  215.         return this.hsmOCSPConfigMapIDtoConfig.get(idK);
  216.     }
  217.     

  219.     public List<String> getOCSPConfigTypes() {
  220.         List<String> l = new ArrayList<>();
  221.         if(!this.hsmOCSPConfigMapTypeToID.isEmpty()) {
  222.             for (String type : this.hsmOCSPConfigMapTypeToID.keySet()) {
  223.                 l.add(type);
  224.             }
  225.         }
  226.         return l;
  227.     }
  228.     public List<String> getOCSPConfigLabels() {
  229.         List<String> l = new ArrayList<>();
  230.         if(!this.hsmOCSPConfigMapLabelToID.isEmpty()) {
  231.             for (String label : this.hsmOCSPConfigMapLabelToID.keySet()) {
  232.                 l.add(label);
  233.             }
  234.         }
  235.         return l;
  236.     }
  237.     public SortedMap<String> getOCSPConfigTypesLabels() {
  238.         return this.hsmOCSPConfigSortedMapTypeLabel;
  239.     }
  240.     
  241.     public boolean existsOCSPConfig(String ocspConfigType) {
  242.         if(ocspConfigType==null) {
  243.             return false;
  244.         }
  245.         for (String type : this.hsmOCSPConfigMapTypeToID.keySet()) {
  246.             if(ocspConfigType.equalsIgnoreCase(type)) {
  247.                 return true;
  248.             }
  249.         }
  250.         return false;
  251.     }
  252. }
Created with JaCoCo 0.8.8.202204050719