CRLParams.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.utils.certificate.ocsp;

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

  29. import org.openspcoop2.utils.LoggerBuffer;
  30. import org.openspcoop2.utils.UtilsException;
  31. import org.openspcoop2.utils.UtilsMultiException;
  32. import org.openspcoop2.utils.certificate.ArchiveLoader;
  33. import org.openspcoop2.utils.certificate.AuthorityInformationAccess;
  34. import org.openspcoop2.utils.certificate.CRLCertstore;
  35. import org.openspcoop2.utils.certificate.CRLDistributionPoint;
  36. import org.openspcoop2.utils.certificate.CRLDistributionPoints;
  37. import org.openspcoop2.utils.certificate.Certificate;
  38. import org.openspcoop2.utils.certificate.CertificateInfo;
  39. import org.openspcoop2.utils.certificate.KeyStore;
  40. import org.openspcoop2.utils.certificate.KeystoreType;
  41. import org.openspcoop2.utils.transport.TransportUtils;

  43. /**
  44.  * OCSPRequestParams
  45.  *
  46.  * @author Poli Andrea (apoli@link.it)
  47.  * @author $Author$
  48.  * @version $Rev$, $Date$
  49.  */
  50. public class CRLParams {

  52.     private KeyStore crlTrustStore;
  53.     private CertStore crlCertstore;
  54.         
  55.     public KeyStore getCrlTrustStore() {
  56.         return this.crlTrustStore;
  57.     }
  58.     public void setCrlTrustStore(KeyStore crlTrustStore) {
  59.         this.crlTrustStore = crlTrustStore;
  60.     }
  61.     public CertStore getCrlCertstore() {
  62.         return this.crlCertstore;
  63.     }
  64.     public void setCrlCertstore(CertStore crlCertstore) {
  65.         this.crlCertstore = crlCertstore;
  66.     }
  67.     
  68.     public static CRLParams build(LoggerBuffer log, X509Certificate certificate, String crlInputConfig, KeyStore trustStore, OCSPConfig config, IOCSPResourceReader reader) throws UtilsException {
  69.         CertificateInfo cer = new CertificateInfo(certificate, "ocspVerifica");
  70.         return build(log, cer, crlInputConfig, trustStore, config, reader);
  71.     }
  72.     public static CRLParams build(LoggerBuffer log, CertificateInfo certificate, String crlInputConfig, KeyStore trustStore, OCSPConfig config, IOCSPResourceReader reader) throws UtilsException {
  73.     
  74.         if(config==null) {
  75.             throw new UtilsException("Param config is null");
  76.         }
  77.         if(certificate==null) {
  78.             throw new UtilsException("Param certificate is null");
  79.         }
  80.         
  81.         
  82.         // comprendo path CRL
  83.         List<String> crlPaths = new ArrayList<>();
  84.         Map<String, byte[]> localResources = new HashMap<>();
  85.         
  86.         if(config.getCrlSource()!=null && !config.getCrlSource().isEmpty()) {
  87.             
  88.             List<Throwable> listExceptions = new ArrayList<>();
  89.                         
  90.             for (CertificateSource s : config.getCrlSource()) {
  91.                 if(CertificateSource.CONFIG.equals(s)) {
  92.                     if(crlInputConfig!=null) {
  93.                         // รจ possibile fornire un'unica indicazione di una risorsa remota o in alternativa N file crl
  94.                         if(TransportUtils.isRemoteResource(crlInputConfig)){
  95.                             readCrlPath(crlInputConfig.trim(),
  96.                                     crlPaths, localResources,
  97.                                     listExceptions,
  98.                                     reader,
  99.                                     log);
  100.                         }
  101.                         else {
  102.                             List<String> l = CRLCertstore.readCrlPaths(crlInputConfig);
  103.                             if(l!=null && !l.isEmpty()) {
  104.                                 for (String crlPath : l) {
  105.                                     String p = crlPath.trim();
  106.                                     if(!crlPaths.contains(p)) {
  107.                                         crlPaths.add(p);
  108.                                         log.debug("OCSP-CRL: add config path '"+p+"'");
  109.                                     }
  110.                                 }
  111.                             }
  112.                         }
  113.                     }
  114.                     if(!crlPaths.isEmpty()) {
  115.                         break;
  116.                     }
  117.                 }
  118.                 else if(CertificateSource.ALTERNATIVE_CONFIG.equals(s)) {
  119.                     List<String> l = null;
  120.                     if(config.getCrlAlternative()!=null) {
  121.                         l = config.getCrlAlternative();
  122.                     }
  123.                     if(l!=null && !l.isEmpty()) {
  124.                         for (String crlPath : l) {
  125.                             String p = crlPath.trim();
  126.                             if(!crlPaths.contains(p)) {
  127.                                 crlPaths.add(p);
  128.                                 log.debug("OCSP-CRL: add alternative config path '"+p+"'");
  129.                             }
  130.                         }
  131.                     }
  132.                     if(!crlPaths.isEmpty()) {
  133.                         break;
  134.                     }
  135.                 }
  136.                 else if(CertificateSource.AUTHORITY_INFORMATION_ACCESS.equals(s)) {
  137.                     try {
  138.                         CRLDistributionPoints crls = certificate.getCRLDistributionPoints();
  139.                         if(crls!=null) {
  140.                             List<CRLDistributionPoint> crlsList = crls.getCRLDistributionPoints();
  141.                             if(crlsList!=null && !crlsList.isEmpty()) {
  142.                                 for (CRLDistributionPoint crlDP : crlsList) {
  143.                                     List<String> l = crlDP.getDistributionPointNames();
  144.                                     if(l!=null) {
  145.                                         for (String crlPath : l) {
  146.                                             readCrlPath(crlPath,
  147.                                                     crlPaths, localResources,
  148.                                                     listExceptions,
  149.                                                     reader,
  150.                                                     log);
  151.                                         }
  152.                                     }
  153.                                 }
  154.                             }
  155.                         }                       
  156.                     }catch(Exception t) {
  157.                         throw new UtilsException(t.getMessage(),t);
  158.                     }
  159.                     if(!crlPaths.isEmpty()) {
  160.                         break;
  161.                     }
  162.                 }
  163.             }
  164.             
  165.             if(crlPaths.isEmpty()) {
  166.                 boolean reject = false;
  167.                 boolean isCA = false;
  168.                 try {
  169.                     isCA = certificate.isCA();
  170.                 }catch(Exception t) {
  171.                     throw new UtilsException(t.getMessage(),t);
  172.                 }
  173.                 if(isCA) {
  174.                     reject = config.isRejectsCAWithoutCRL();
  175.                 }
  176.                 else {
  177.                     reject = config.isRejectsCertificateWithoutCRL();
  178.                 }
  179.                 if(reject) {
  180.                     if(!listExceptions.isEmpty()) {
  181.                         if(listExceptions.size()==1) {
  182.                             Throwable t = listExceptions.get(0);
  183.                             if(t!=null) {
  184.                                 throw new UtilsException("Crl retrieve failed; "+t.getMessage(),t);
  185.                             }
  186.                         }
  187.                         UtilsMultiException multi = new UtilsMultiException("Crl retrieve failed", listExceptions.toArray(new Throwable[1]));
  188.                         throw new UtilsException("Crl retrieve failed;\n"+multi.getMultiMessage(),multi);
  189.                     }
  190.                     else {
  191.                         throw new UtilsException("Crl retrieve failed");
  192.                     }
  193.                 }
  194.             }
  195.             
  196.         }
  197.         
  198.         KeyStore crlTrustStore = null;
  199.         if(!crlPaths.isEmpty() &&
  200.             // comprendo issuer del certificato da validare
  201.             config.getCrlTrustStoreSource()!=null && !config.getCrlTrustStoreSource().isEmpty()) {
  202.             for (CertificateSource s : config.getCrlTrustStoreSource()) {
  203.                 if(CertificateSource.CONFIG.equals(s)) {
  204.                     if(trustStore!=null) {
  205.                         try {
  206.                             if(crlTrustStore==null) {
  207.                                 java.security.KeyStore ks = java.security.KeyStore.getInstance(KeystoreType.JKS.getNome());
  208.                                 ks.load(null, null);
  209.                                 crlTrustStore = new KeyStore(ks);
  210.                             }
  211.                         }catch(Exception t) {
  212.                             String msgError = "OCSP-CRL [crlssuer: CONFIG] retrieve failed: "+t.getMessage();
  213.                             log.debug(msgError,t);
  214.                         }
  215.                         if(crlTrustStore!=null) {
  216.                             crlTrustStore.putAllCertificate(trustStore, false);
  217.                         }
  218.                         log.debug("OCSP-CRL: add certificate in truststore config");
  219.                     }
  220.                 }
  221.                 else if(CertificateSource.ALTERNATIVE_CONFIG.equals(s)) {
  222.                     KeyStore alternativeTrustStore = null;
  223.                     if(config.getAlternativeTrustStoreCRLPath()!=null) {
  224.                         alternativeTrustStore = reader.getCrlAlternativeTrustStore();
  225.                     }
  226.                     if(alternativeTrustStore!=null) {
  227.                         try {
  228.                             if(crlTrustStore==null) {
  229.                                 java.security.KeyStore ks = java.security.KeyStore.getInstance(KeystoreType.JKS.getNome());
  230.                                 ks.load(null, null);
  231.                                 crlTrustStore = new KeyStore(ks);
  232.                             }
  233.                         }catch(Exception t) {
  234.                             String msgError = "OCSP-CRL [crlssuer: ALTERNATIVE_CONFIG] retrieve failed: "+t.getMessage();
  235.                             log.debug(msgError,t);
  236.                         }
  237.                         if(crlTrustStore!=null) {
  238.                             crlTrustStore.putAllCertificate(alternativeTrustStore, false);
  239.                         }
  240.                         log.debug("OCSP-CRL: add certificate in alternative truststore config");
  241.                     }
  242.                 }
  243.                 else if(CertificateSource.AUTHORITY_INFORMATION_ACCESS.equals(s)) {
  244.                     try {
  245.                         CRLDistributionPoints crls = certificate.getCRLDistributionPoints();
  246.                         if(crls!=null) {
  247.                             List<CRLDistributionPoint> crlsList = crls.getCRLDistributionPoints();
  248.                             int indexCrl = 0;
  249.                             if(crlsList!=null && !crlsList.isEmpty()) {
  250.                                 for (CRLDistributionPoint crlDP : crlsList) {
  251.                                     List<String> l = crlDP.getCRLIssuers();
  252.                                     if(l!=null) {
  253.                                         for (String crlPath : l) {
  254.                                             if(!crlPaths.contains(crlPath)) {
  255.                                                 try {
  256.                                                     Map<String, byte[]> map = new HashMap<>();
  257.                                                     reader.readExternalResource(crlPath, map);
  258.                                                     byte [] issuer = null;
  259.                                                     if(!map.isEmpty()) {
  260.                                                         issuer = map.get(crlPath);
  261.                                                     }
  262.                                                     if(issuer==null || issuer.length<=0) {
  263.                                                         throw new UtilsException("empty resource");
  264.                                                     }
  265.                                                     Certificate cer = ArchiveLoader.load(issuer);
  266.                                                     if(cer!=null && cer.getCertificate()!=null) {
  267.                                                         if(crlTrustStore==null) {
  268.                                                             java.security.KeyStore ks = java.security.KeyStore.getInstance(KeystoreType.JKS.getNome());
  269.                                                             ks.load(null, null);
  270.                                                             crlTrustStore = new KeyStore(ks);
  271.                                                         }
  272.                                                         crlTrustStore.putCertificate("crlIssuerCert-"+indexCrl, cer.getCertificate().getCertificate(), false);
  273.                                                         indexCrl++;
  274.                                                         log.debug("OCSP-CRL: add certificate retrieved from '"+crlPath+"'");
  275.                                                     }
  276.                                                 }catch(Exception t) {
  277.                                                     String msgError = "OCSP-CRL [crlssuer: "+crlPath+"] retrieve failed: "+t.getMessage();
  278.                                                     log.debug(msgError,t);
  279.                                                 }
  280.                                             }
  281.                                         }
  282.                                     }
  283.                                 }
  284.                             }
  285.                         }                       
  286.                     }catch(Exception t) {
  287.                         throw new UtilsException(t.getMessage(),t);
  288.                     }
  289.                     try {
  290.                         AuthorityInformationAccess aia = certificate.getAuthorityInformationAccess();
  291.                         if(aia!=null) {
  292.                             List<String> issuer = aia.getCAIssuers();
  293.                             int indexAia = 0;
  294.                             if(issuer!=null && !issuer.isEmpty()) {
  295.                                 for (String urlIssuer : issuer) {
  296.                                     Map<String, byte[]> map = new HashMap<>();
  297.                                     reader.readExternalResource(urlIssuer, map);
  298.                                     if(!map.isEmpty()) {
  299.                                         byte [] issCert = map.get(urlIssuer);
  300.                                         if(issCert!=null) {
  301.                                             Certificate cer = ArchiveLoader.load(issCert);
  302.                                             if(cer!=null && cer.getCertificate()!=null) {
  303.                                                 if(crlTrustStore==null) {
  304.                                                     java.security.KeyStore ks = java.security.KeyStore.getInstance(KeystoreType.JKS.getNome());
  305.                                                     ks.load(null, null);
  306.                                                     crlTrustStore = new KeyStore(ks);
  307.                                                 }
  308.                                                 crlTrustStore.putCertificate("aiaIssuerCert-"+indexAia, cer.getCertificate().getCertificate(), false);
  309.                                                 indexAia++;
  310.                                                 log.debug("OCSP-CRL-AIA: add certificate retrieved from '"+urlIssuer+"'");
  311.                                             }
  312.                                         }
  313.                                     }
  314.                                 }
  315.                             }
  316.                         }
  317.                     }catch(Exception t) {
  318.                         throw new UtilsException(t.getMessage(),t);
  319.                     }
  320.                 }
  321.             }
  322.             
  323.         }
  324.         
  325.         CRLParams params = new CRLParams();
  326.         if(!crlPaths.isEmpty()) {
  327.             params.crlCertstore = reader.readCRL(crlPaths, localResources).getCertStore();
  328.             
  329. /**         boolean newTrustStore = false;
  330. //          if(crlTrustStore==null) {
  331. //              try {
  332. //                  java.security.KeyStore ks = java.security.KeyStore.getInstance(KeystoreType.JKS.getNome());
  333. //                  ks.load(null, null);
  334. //                  crlTrustStore = new KeyStore(ks);
  335. //                  newTrustStore = true;
  336. //              }catch(Throwable t) {
  337. //                  throw new UtilsException(t.getMessage(),t);
  338. //              }
  339. //          }
  340. //          
  341. //          try {
  342. //              if(certificate.isCA()) {
  343. //                  if(newTrustStore || (!params.crlTrustStore.existsCertificateBySubject(certificate.getCertificate().getSubjectX500Principal()))) {
  344. //                      crlTrustStore.putCertificate("ca", certificate.getCertificate(), false);
  345. //                  }
  346. //              }
  347. //          }catch(Throwable t) {
  348. //              throw new UtilsException(t.getMessage(),t);
  349. //          }*/
  350.             
  351.             params.crlTrustStore = crlTrustStore;
  352.         }
  353.         
  354.         return params;
  355.         
  356.     }
  357.     
  358.     private static void readCrlPath(String crlPath,
  359.             List<String> crlPaths,Map<String, byte[]> localResources,
  360.             List<Throwable> listExceptions,
  361.             IOCSPResourceReader reader,
  362.             LoggerBuffer log) {
  363.         if(!crlPaths.contains(crlPath)) {
  364.             try {
  365.                 Map<String, byte[]> map = new HashMap<>();
  366.                 reader.readExternalResource(crlPath, map);
  367.                 byte [] crl = null;
  368.                 if(!map.isEmpty()) {
  369.                     crl = map.get(crlPath);
  370.                 }
  371.                 if(crl==null || crl.length<=0) {
  372.                     throw new UtilsException("empty resource");
  373.                 }
  374.                 localResources.put(crlPath, crl);
  375.                 crlPaths.add(crlPath);
  376.                 log.debug("OCSP-CRL: add external resource '"+crlPath+"'");
  377.             }catch(Exception t) {
  378.                 String msgError = "[crl: "+crlPath+"] retrieve failed: "+t.getMessage();
  379.                 log.debug("OCSP-CRL "+msgError,t);
  380.                 listExceptions.add(new Exception(msgError,t));
  381.             }
  382.         }
  383.     }
  384. }
Created with JaCoCo 0.8.8.202204050719