CertificateUtils.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.protocol.registry;

  22. import java.io.File;
  23. import java.io.InputStream;
  24. import java.security.PrivateKey;
  25. import java.security.cert.X509Certificate;
  26. import java.text.SimpleDateFormat;
  27. import java.util.ArrayList;
  28. import java.util.Enumeration;
  29. import java.util.List;

  31. import javax.crypto.SecretKey;

  33. import org.apache.commons.lang.StringUtils;
  34. import org.openspcoop2.core.constants.CostantiLabel;
  35. import org.openspcoop2.core.constants.StatoCheck;
  36. import org.openspcoop2.utils.LoggerBuffer;
  37. import org.openspcoop2.utils.Utilities;
  38. import org.openspcoop2.utils.UtilsException;
  39. import org.openspcoop2.utils.certificate.ArchiveLoader;
  40. import org.openspcoop2.utils.certificate.CRLCertstore;
  41. import org.openspcoop2.utils.certificate.Certificate;
  42. import org.openspcoop2.utils.certificate.CertificateInfo;
  43. import org.openspcoop2.utils.certificate.JWKSet;
  44. import org.openspcoop2.utils.certificate.KeyUtils;
  45. import org.openspcoop2.utils.certificate.KeystoreParams;
  46. import org.openspcoop2.utils.certificate.KeystoreType;
  47. import org.openspcoop2.utils.certificate.hsm.HSMManager;
  48. import org.openspcoop2.utils.certificate.hsm.HSMUtils;
  49. import org.openspcoop2.utils.certificate.ocsp.IOCSPResourceReader;
  50. import org.openspcoop2.utils.certificate.ocsp.OCSPResourceReader;
  51. import org.openspcoop2.utils.certificate.ocsp.OCSPValidatorImpl;
  52. import org.openspcoop2.utils.date.DateManager;
  53. import org.openspcoop2.utils.resources.Charset;
  54. import org.openspcoop2.utils.resources.FileSystemUtilities;
  55. import org.openspcoop2.utils.transport.http.IBYOKUnwrapManager;
  56. import org.openspcoop2.utils.transport.http.IOCSPValidator;
  57. import org.slf4j.Logger;

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

  70.     private static final String FORMAT_DATE_CERTIFICATE = "dd/MM/yyyy HH:mm";
  71.     
  72.     public static String toString(Certificate certificate, String separator, String newLine) throws UtilsException {
  73.         StringBuilder sb = new StringBuilder();
  74.         
  75.         SimpleDateFormat sdf = new SimpleDateFormat(FORMAT_DATE_CERTIFICATE);
  76.         
  77.         String certificatoSubject = certificate.getCertificate().getSubject().getNameNormalized();
  78.         boolean certificatoSelfSigned = certificate.getCertificate().isSelfSigned();
  79.         String certificatoIssuer = null;
  80.         if(!certificatoSelfSigned) {
  81.             certificatoIssuer = certificate.getCertificate().getIssuer().getNameNormalized();
  82.         }
  83.         sb.append(CostantiLabel.CERTIFICATE_SUBJECT).append(separator).append(certificatoSubject);
  84.         if(certificatoSelfSigned) {
  85.             sb.append(newLine).append(CostantiLabel.CERTIFICATE_SELF_SIGNED);
  86.         }
  87.         else {
  88.             sb.append(newLine).append(CostantiLabel.CERTIFICATE_ISSUER).append(separator).append(certificatoIssuer);
  89.         }
  90.         
  91.         String notBefore = null;
  92.         if(certificate.getCertificate().getNotBefore()!=null) {
  93.             notBefore = sdf.format(certificate.getCertificate().getNotBefore());
  94.         }
  95.         String notAfter = null;
  96.         if(certificate.getCertificate().getNotAfter()!=null) {
  97.             notAfter = sdf.format(certificate.getCertificate().getNotAfter());
  98.         }
  99.         if(notBefore!=null) {
  100.             sb.append(newLine).append(CostantiLabel.CERTIFICATE_NOT_BEFORE).append(separator).append(notBefore);
  101.         }
  102.         if(notAfter!=null) {
  103.             sb.append(newLine).append(CostantiLabel.CERTIFICATE_NOT_AFTER).append(separator).append(notAfter);
  104.         }
  105.         
  106.         /** String serialNumber = certificate.getCertificate().getSerialNumber() + ""; */
  107.         String serialNumberHex = certificate.getCertificate().getSerialNumberHex() + "";
  108.         /** sb.append(newLine).append(CostantiLabel.CERTIFICATE_SERIAL_NUMBER).append(separator).append(serialNumber);
  109.         //sb.append(newLine).append(CostantiLabel.CERTIFICATE_SERIAL_NUMBER_HEX).append(separator).append(serialNumberHex); */
  110.         sb.append(newLine).append(CostantiLabel.CERTIFICATE_SERIAL_NUMBER).append(separator).append(serialNumberHex);
  111.         
  112.         /** String certificatoType = certificate.getCertificate().getType();
  113.         //String certificatoVersion = certificate.getCertificate().getVersion() + ""; */
  114.         
  115.         return sb.toString();
  116.     }
  117.     
  118.     public static String toStringKeyStore(KeystoreParams params,
  119.             String separator, String newLine) {
  120.         return toStringEngine(true, params.getKeyAlias(), 
  121.                 null, params.getByokPolicy(),
  122.                 params.getPath(), params.getType(), 
  123.                 separator, newLine);
  124.     }
  125.     public static String toStringKeyStore(String storePath, String storeType,
  126.             String byokPolicy,
  127.             String keyAlias,
  128.             String separator, String newLine) {
  129.         return toStringEngine(true, keyAlias, 
  130.                 null, byokPolicy,
  131.                 storePath, storeType, 
  132.                 separator, newLine);
  133.     }
  134.     public static String toStringTrustStore(KeystoreParams params,
  135.             String separator, String newLine) {
  136.         return toStringEngine(false, params.getKeyAlias(), 
  137.                 params.getCrls(), params.getOcspPolicy(),
  138.                 params.getPath(), params.getType(), 
  139.                 separator, newLine);
  140.     }
  141.     public static String toStringTrustStore(String storePath, String storeType,
  142.             String trustCRL, String ocspPolicy,
  143.             String separator, String newLine) {
  144.         return toStringTrustStore(storePath, storeType,
  145.                 trustCRL, ocspPolicy,
  146.                 null,
  147.                 separator, newLine);
  148.     }
  149.     public static String toStringTrustStore(String storePath, String storeType,
  150.             String trustCRL, String ocspPolicy,
  151.             String certAlias,
  152.             String separator, String newLine) {
  153.         return toStringEngine(false, certAlias, 
  154.                 trustCRL, ocspPolicy,
  155.                 storePath, storeType, 
  156.                 separator, newLine);
  157.     }
  158.     private static String toStringEngine(boolean keystore, String keyAlias, 
  159.             String trustCRL, String policy, // policy è ocspPolicy in truststore e byokPolicy in keystore; nel caso di keystore crl è inutilizzato
  160.             String storePath, String storeType, 
  161.             String separator, String newLine) {
  162.         
  163.         StringBuilder sb = new StringBuilder();
  164.         
  165.         sb.append(keystore? CostantiLabel.KEYSTORE : CostantiLabel.TRUSTSTORE);
  166.         sb.append(separator);
  167.         boolean hsm = HSMUtils.isKeystoreHSM(separator);
  168.         String location = storePath;
  169.         if(hsm) {
  170.             location = CostantiLabel.STORE_HSM;
  171.         }
  172.         sb.append("(").append(storeType).append(") ").append(location);
  173.         
  174.         if(!keystore && trustCRL!=null) {
  175.             sb.append(newLine);
  176.             sb.append(CostantiLabel.CRLS);
  177.             sb.append(separator);
  178.             sb.append(trustCRL);
  179.         }
  180.         
  181.         if(policy!=null) {
  182.             sb.append(newLine);
  183.             sb.append(keystore ? CostantiLabel.BYOK_POLICY : CostantiLabel.OCSP_POLICY);
  184.             sb.append(separator);
  185.             sb.append(policy);
  186.         }
  187.         
  188.         if(keyAlias!=null) {
  189.             sb.append(newLine);
  190.             if(keystore) {
  191.                 sb.append(CostantiLabel.KEY_ALIAS);
  192.             }
  193.             else {
  194.                 sb.append(CostantiLabel.CERTIFICATE_ALIAS);
  195.             }
  196.             sb.append(separator);
  197.             sb.append(keyAlias);
  198.         }
  199.         
  200.         return sb.toString();
  201.     }
  202.     
  203.     
  204.     public static KeystoreParams readKeyStoreParamsJVM() {
  205.         
  206.         KeystoreParams params = null;
  207.         
  208.         String keyStoreLocation = System.getProperty("javax.net.ssl.keyStore");
  209.         String keyStoreType = System.getProperty("javax.net.ssl.keyStoreType");
  210.         String keyStorePassword = System.getProperty("javax.net.ssl.keyStorePassword");
  211.         
  212.         if(keyStoreLocation!=null || keyStoreType!=null) {
  213.             if(keyStoreLocation==null) {
  214.                 keyStoreLocation = "NONE";
  215.             }
  216.             if(keyStoreType==null) {
  217.                 keyStoreType = KeystoreType.JKS.getNome();
  218.             }
  219.             params = new KeystoreParams();
  220.             params.setPath(keyStoreLocation);
  221.             params.setType(keyStoreType);
  222.             params.setPassword(keyStorePassword);
  223.             params.setKeyPassword(keyStorePassword); // uguale in java
  224.         }
  225.     
  226.         return params;
  227.     }
  228.     
  229.     public static KeystoreParams readTrustStoreParamsJVM() {
  230.         
  231.         KeystoreParams params = null;
  232.         
  233.         String trustStoreLocation = System.getProperty("javax.net.ssl.trustStore");
  234.         String trustStoreType = System.getProperty("javax.net.ssl.trustStoreType");
  235.         String trustStorePassword = System.getProperty("javax.net.ssl.trustStorePassword");
  236.         
  237.         if(trustStoreLocation!=null) {
  238.             if(trustStoreType==null) {
  239.                 trustStoreType = KeystoreType.JKS.getNome();
  240.             }
  241.             params = new KeystoreParams();
  242.             params.setPath(trustStoreLocation);
  243.             params.setType(trustStoreType);
  244.             params.setPassword(trustStorePassword);
  245.         }
  246.     
  247.         return params;
  248.     }
  249.     
  250.     private static final String NOT_EXISTS_STRING = " not exists";
  251.     private static final String CANNOT_READ_STRING = " cannot read";
  252.     private static final String READING_PREFIX_STRING = "Reading ";
  253.     private static final String SERIAL_NUMBER_STRING = " serialNumber:";
  254.     private static String getSuffixCertificateNotValid(Exception t) {
  255.         return " non risulta valido: "+t.getMessage();
  256.     }
  257.     private static String getSuffixFailed(Exception t) {
  258.         return " failed: "+t.getMessage();
  259.     }
  260.     
  261.     public static CertificateCheck checkCertificateClient(List<byte[]>certs, List<Boolean> strictValidation, int sogliaWarningGiorni, 
  262.             boolean addCertificateDetails, String separator, String newLine,
  263.             Logger log) throws UtilsException{
  264.         
  265.         SimpleDateFormat sdf = new SimpleDateFormat(FORMAT_DATE_CERTIFICATE);
  266.         
  267.         if(certs==null || certs.isEmpty()) {
  268.             throw new UtilsException("Nessun certificato individuato");
  269.         }
  270.         if(strictValidation==null || strictValidation.isEmpty()) {
  271.             throw new UtilsException("Nessuna informazione sul tipo di validazione fornita");
  272.         }
  273.         if(strictValidation.size()!=certs.size()) {
  274.             throw new UtilsException("Rilevata inconsistenza tra le informazioni fornite sul tipo di validazione e i certificati");
  275.         }
  276.         
  277.         CertificateCheck esito = new CertificateCheck();
  278.                 
  279.         boolean error = false;
  280.         boolean warning = false;
  281.         boolean almostOneValid = false;
  282.         for (int i = 0; i < certs.size(); i++) {
  283.             boolean principale = (i==0);
  284.             Certificate certificate = null;
  285.             String identitaCertificato = "Certificato "+ (principale ? "principale" : "n."+(i+1)); 
  286.             String credenziale = "Certificato";
  287.             if(principale && certs.size()>1) {
  288.                 credenziale = credenziale + " principale";
  289.             }
  290.             try {
  291.                 byte [] bytesCert = certs.get(i);
  292.                 boolean strictValidationCert = strictValidation.get(i);
  293.                 certificate = ArchiveLoader.load(bytesCert);
  294.                 
  295.                 String hex = certificate.getCertificate().getSerialNumberHex();
  296.                 String certificateDetails = null;
  297.                 if(addCertificateDetails) {
  298.                     certificateDetails = CertificateUtils.toString(certificate, separator, newLine);
  299.                 }
  300.                 else {
  301.                     credenziale = credenziale+ " (CN:"+certificate.getCertificate().getSubject().getCN()+SERIAL_NUMBER_STRING+hex+")";
  302.                 }
  303.                 boolean check = true;
  304.                 try {
  305.                     certificate.getCertificate().checkValid();
  306.                 }catch(Exception t) {
  307.                     check = false;
  308.                     if(strictValidationCert) {
  309.                         String msgErrore = credenziale+" non valido: "+t.getMessage();
  310.                         error = true;
  311.                         esito.addError(identitaCertificato, msgErrore, certificateDetails);
  312.                         continue;
  313.                     }
  314.                     else {
  315.                         String msgErrore = credenziale+" utilizzato per attivare la validazione tramite Subject e Issuer non risulta valido: "+t.getMessage();
  316.                         warning = true;
  317.                         esito.addWarning(identitaCertificato, msgErrore, certificateDetails);
  318.                     }
  319.                 }
  320.                                     
  321.                 if(check && certificate.getCertificateChain()!=null && !certificate.getCertificateChain().isEmpty()) {
  322.                     for (CertificateInfo caChain : certificate.getCertificateChain()) {
  323.                         String hexCaChain = caChain.getSerialNumberHex();
  324.                         String credenzialeCaChain = "(CN:"+caChain.getSubject().getCN()+SERIAL_NUMBER_STRING+hexCaChain+")";
  325.                         try {
  326.                             caChain.checkValid();
  327.                         }catch(Exception t) {
  328.                             check = false;
  329.                             String msgErrore = (credenziale+"; un certificato della catena "+credenzialeCaChain+getSuffixCertificateNotValid(t));
  330.                             if(strictValidationCert) {
  331.                                 error = true;
  332.                                 esito.addError(identitaCertificato, msgErrore, certificateDetails);
  333.                                 continue;
  334.                             }
  335.                             else {
  336.                                 warning = true;
  337.                                 esito.addWarning(identitaCertificato, msgErrore, certificateDetails);
  338.                             }
  339.                         }
  340.                     }
  341.                 }
  342.                 
  343.                 if(check && sogliaWarningGiorni>0 &&
  344.                     certificate.getCertificate().getNotAfter()!=null) {
  345.                     long expire = certificate.getCertificate().getNotAfter().getTime();
  346.                     long now = DateManager.getTimeMillis();
  347.                     long diff = expire - now;
  348.                     long soglia = (1000l*60l*60l*24l) * ((long)sogliaWarningGiorni);
  349.                     /**System.out.println("=======================");
  350.                     //System.out.println("SUBJECT ["+certificate.getCertificate().getCertificate().getSubjectDN().getName()+"]");
  351.                     //System.out.println("NOT AFTER ["+certificate.getCertificate().getNotAfter()+"]");
  352.                     //System.out.println("SOGLIA ["+sogliaWarningGiorni+"]");
  353.                     //System.out.println("DEXP ["+expire+"]");
  354.                     //System.out.println("DNOW ["+now+"]");
  355.                     //System.out.println("DIFF ["+diff+"]");
  356.                     //System.out.println("SOGLIATR ["+soglia+"]");*/
  357.                     if(diff<soglia) {
  358.                         String msgErrore = credenziale+" prossima alla scadenza ("+sogliaWarningGiorni+" giorni): "+sdf.format(certificate.getCertificate().getNotAfter());
  359.                         warning = true;
  360.                         esito.addWarning(identitaCertificato, msgErrore, certificateDetails);
  361.                     }
  362.                 }
  363.                 
  364.             }catch(Exception t) {
  365.                 // non dovrebbe succedere
  366.                 String msgError = "L'analisi del certificato ha prodotto un errore non atteso: "+t.getMessage();
  367.                 esito.addError(identitaCertificato, msgError, null);
  368.                 log.error(msgError, t); 
  369.                 error = true;
  370.                 continue;
  371.             }
  372.                 
  373.             almostOneValid = true;
  374.         }
  375.         
  376.         
  377.         if(almostOneValid) {
  378.             if(error || warning) {
  379.                 esito.setStatoCheck(StatoCheck.WARN);
  380.             }
  381.             else {
  382.                 esito.setStatoCheck(StatoCheck.OK);
  383.             }
  384.         }
  385.         else {
  386.             esito.setStatoCheck(StatoCheck.ERROR);
  387.         }
  388.         return esito;

  390.     }
  391.     
  392.     public static CertificateCheck checkTrustStore(String trustStore, boolean classpathSupported, String type, String password, String trustStoreCrls, String ocspPolicy,
  393.             int sogliaWarningGiorni, 
  394.             boolean addCertificateDetails, String separator, String newLine,
  395.             Logger log) throws UtilsException{
  396.         return checkTrustStore(trustStore, classpathSupported, type, password, trustStoreCrls, ocspPolicy, null,
  397.                 sogliaWarningGiorni, 
  398.                 addCertificateDetails, separator, newLine,
  399.                 log);
  400.     }
  401.     public static CertificateCheck checkTrustStore(String trustStore, boolean classpathSupported, String type, String password, String trustStoreCrls,String ocspPolicy,String certAlias,
  402.             int sogliaWarningGiorni, 
  403.             boolean addCertificateDetails, String separator, String newLine,
  404.             Logger log) throws UtilsException{
  405.         
  406.         boolean hsm = HSMUtils.isKeystoreHSM(type);
  407.         byte [] keystoreBytes = null;
  408.         if(!hsm) {
  409.             File f = new File(trustStore);
  410.             boolean exists = f.exists();
  411.             boolean inClasspath = false;
  412.             if(!exists && classpathSupported) {
  413.                 String uri = trustStore;
  414.                 if(!trustStore.startsWith("/")) {
  415.                     uri = "/" + uri;    
  416.                 }
  417.                 try {
  418.                     try( InputStream is = CertificateUtils.class.getResourceAsStream(uri); ){
  419.                         exists = (is!=null);
  420.                         if(exists) {
  421.                             inClasspath = true;
  422.                             keystoreBytes = Utilities.getAsByteArray(is);
  423.                         }
  424.                     }
  425.                 }catch(Exception e) {
  426.                     throw new UtilsException(e.getMessage(),e);
  427.                 }
  428.             }
  429.             if(!exists || (!inClasspath && !f.canRead())) {
  430.                 
  431.                 String storeDetails = null;
  432.                 if(addCertificateDetails) {
  433.                     storeDetails = toStringTrustStore(trustStore, type, trustStoreCrls, ocspPolicy, certAlias, separator, newLine);
  434.                 }
  435.                 String errorDetails = CostantiLabel.TRUSTSTORE;
  436.                 if(!addCertificateDetails) {
  437.                     errorDetails = errorDetails + " '"+
  438.                             //f.getAbsolutePath()+  // nel caso di path relativo viene visualizzato un PATH basato sul bin di wildfly ed e' forviante
  439.                             trustStore+
  440.                             "'";
  441.                 }
  442.                 errorDetails = errorDetails + (!exists ? NOT_EXISTS_STRING : CANNOT_READ_STRING); 
  443.                 
  444.                 CertificateCheck esito = new CertificateCheck();
  445.                 esito.setStatoCheck(StatoCheck.ERROR);
  446.                 esito.addError(trustStore, errorDetails, storeDetails);
  447.                 return esito;
  448.             }
  449.             if(!inClasspath) {
  450.                 try {
  451.                     keystoreBytes = FileSystemUtilities.readBytesFromFile(f);
  452.                 }catch(Exception e) {
  453.                     throw new UtilsException(e.getMessage(),e);
  454.                 }
  455.             }
  456.         }
  457.         return checkStore(false, certAlias, null, 
  458.                 trustStoreCrls, ocspPolicy, null,
  459.                 trustStore, keystoreBytes, type, password, 
  460.                 sogliaWarningGiorni, 
  461.                 addCertificateDetails, separator, newLine,
  462.                 log);
  463.     }
  464.     public static CertificateCheck checkTrustStore(String trustStorePath, byte[] trustStore, String type, String password, String trustStoreCrls, String ocspPolicy,
  465.             int sogliaWarningGiorni, 
  466.             boolean addCertificateDetails, String separator, String newLine,
  467.             Logger log) throws UtilsException{
  468.         return checkStore(false, null, null, 
  469.                 trustStoreCrls, ocspPolicy, null,
  470.                 trustStorePath!=null ? trustStorePath : CostantiLabel.STORE_CARICATO_BASEDATI, trustStore, type, password, 
  471.                 sogliaWarningGiorni, 
  472.                 addCertificateDetails, separator, newLine,
  473.                 log);
  474.     }
  475.     public static CertificateCheck checkTrustStore(String trustStorePath, byte[] trustStore, String type, String password, String trustStoreCrls, String ocspPolicy,
  476.             String alias,
  477.             int sogliaWarningGiorni, 
  478.             boolean addCertificateDetails, String separator, String newLine,
  479.             Logger log) throws UtilsException{
  480.         return checkStore(false, alias, null, 
  481.                 trustStoreCrls, ocspPolicy, null,
  482.                 trustStorePath!=null ? trustStorePath : CostantiLabel.STORE_CARICATO_BASEDATI, trustStore, type, password, 
  483.                 sogliaWarningGiorni, 
  484.                 addCertificateDetails, separator, newLine,
  485.                 log);
  486.     }
  487.     public static CertificateCheck checkKeyStore(String keyStore, boolean classpathSupported, String type, String password, IBYOKUnwrapManager byokUnwrapManager, 
  488.             String aliasKey, String passwordKey, 
  489.             int sogliaWarningGiorni, 
  490.             boolean addCertificateDetails, String separator, String newLine,
  491.             Logger log) throws UtilsException{
  492.         boolean hsm = HSMUtils.isKeystoreHSM(type);
  493.         byte [] keystoreBytes = null;
  494.         if(!hsm) {
  495.             File f = new File(keyStore);
  496.             boolean exists = f.exists();
  497.             boolean inClasspath = false;
  498.             if(!exists && classpathSupported) {
  499.                 String uri = keyStore;
  500.                 if(!keyStore.startsWith("/")) {
  501.                     uri = "/" + uri;    
  502.                 }
  503.                 try {
  504.                     try( InputStream is = CertificateUtils.class.getResourceAsStream(uri); ){
  505.                         exists = (is!=null);
  506.                         if(exists) {
  507.                             inClasspath = true;
  508.                             keystoreBytes = Utilities.getAsByteArray(is);
  509.                         }
  510.                     }
  511.                 }catch(Exception e) {
  512.                     throw new UtilsException(e.getMessage(),e);
  513.                 }
  514.             }
  515.             if(!exists || (!inClasspath && !f.canRead())) {
  516.                 
  517.                 String storeDetails = null;
  518.                 if(addCertificateDetails) {
  519.                     storeDetails = toStringKeyStore(keyStore, type, (byokUnwrapManager!=null ? byokUnwrapManager.getPolicy() : null), aliasKey, separator, newLine);
  520.                 }
  521.                 String errorDetails = CostantiLabel.KEYSTORE;
  522.                 if(!addCertificateDetails) {
  523.                     errorDetails = errorDetails + " '"+
  524.                             //f.getAbsolutePath()+  // nel caso di path relativo viene visualizzato un PATH basato sul bin di wildfly ed e' forviante
  525.                             keyStore+
  526.                             "'";
  527.                 }
  528.                 errorDetails = errorDetails + (!exists ? NOT_EXISTS_STRING : CANNOT_READ_STRING); 
  529.                 
  530.                 CertificateCheck esito = new CertificateCheck();
  531.                 esito.setStatoCheck(StatoCheck.ERROR);
  532.                 esito.addError(keyStore, errorDetails, storeDetails);
  533.                 return esito;
  534.             }
  535.             if(!inClasspath) {
  536.                 try {
  537.                     keystoreBytes = FileSystemUtilities.readBytesFromFile(f);
  538.                 }catch(Exception e) {
  539.                     throw new UtilsException(e.getMessage(),e);
  540.                 }
  541.             }
  542.         }
  543.         return checkStore(true, aliasKey, passwordKey, 
  544.                 null, null, byokUnwrapManager,
  545.                 keyStore, keystoreBytes, type, password, 
  546.                 sogliaWarningGiorni, 
  547.                 addCertificateDetails, separator, newLine,
  548.                 log);
  549.     }
  550.     public static CertificateCheck checkKeyStore(String keyStorePath, byte[] keyStore, String type, String password, IBYOKUnwrapManager byokUnwrapManager, 
  551.             String aliasKey, String passwordKey,
  552.             int sogliaWarningGiorni, 
  553.             boolean addCertificateDetails, String separator, String newLine,
  554.             Logger log) throws UtilsException{
  555.         return checkStore(true, aliasKey, passwordKey, 
  556.                 null, null, byokUnwrapManager,
  557.                 keyStorePath!=null ? keyStorePath : CostantiLabel.STORE_CARICATO_BASEDATI, keyStore, type, password, 
  558.                 sogliaWarningGiorni, 
  559.                 addCertificateDetails, separator, newLine,
  560.                 log);
  561.     }
  562.     private static CertificateCheck checkStore(boolean keystore, String aliasKey, String passwordKey, 
  563.             String trustStoreCrls, String ocspPolicy, IBYOKUnwrapManager byokUnwrapManager,
  564.             String storePath, byte[] storeBytes, String type, String password,
  565.             int sogliaWarningGiorni, 
  566.             boolean addCertificateDetails, String separator, String newLine,
  567.             Logger log) throws UtilsException{
  568.         
  569.         SimpleDateFormat sdf = new SimpleDateFormat(FORMAT_DATE_CERTIFICATE);
  570.         
  571.         String storeDetails = "";
  572.         if(addCertificateDetails) {
  573.             if(keystore) {
  574.                 storeDetails = toStringKeyStore(storePath, type, (byokUnwrapManager!=null ? byokUnwrapManager.getPolicy() : null), aliasKey, separator, newLine);
  575.             }
  576.             else {
  577.                 storeDetails = toStringTrustStore(storePath, type, trustStoreCrls, ocspPolicy, aliasKey, separator, newLine);
  578.             }
  579.         }
  580.                 
  581.         org.openspcoop2.utils.certificate.KeyStore store = null;
  582.         try {
  583.             if(HSMUtils.isKeystoreHSM(type)) {
  584.                 store = HSMManager.getInstance().getKeystore(type);
  585.             }
  586.             else {
  587.                 if(keystore && byokUnwrapManager!=null) {
  588.                     storeBytes = byokUnwrapManager.unwrap(storeBytes);
  589.                 }
  590.                 store = new org.openspcoop2.utils.certificate.KeyStore(storeBytes, type, password);
  591.             }
  592.         }catch(Exception t) {
  593.             CertificateCheck esito = new CertificateCheck();
  594.             esito.setStatoCheck(StatoCheck.ERROR);
  595.             esito.addError(storePath, "Non è possibile accedere al "+(keystore ? CostantiLabel.KEYSTORE : CostantiLabel.TRUSTSTORE)+": "+t.getMessage(), storeDetails);
  596.             return esito;
  597.         }
  598.         
  599.         IOCSPValidator ocspValidator = null;
  600.         CRLCertstore crls = null;       
  601.         if(!keystore && ( 
  602.                 (trustStoreCrls!=null && StringUtils.isNotEmpty(trustStoreCrls)) 
  603.                 || 
  604.                 (ocspPolicy!=null && StringUtils.isNotEmpty(ocspPolicy))
  605.                 )
  606.             ) {
  607.             
  608.             boolean crlByOcsp = false;
  609.             if(ocspPolicy!=null && StringUtils.isNotEmpty(ocspPolicy)) {
  610.                 LoggerBuffer lb = new LoggerBuffer();
  611.                 lb.setLogDebug(log);
  612.                 lb.setLogError(log);
  613.                 IOCSPResourceReader ocspResourceReader = new OCSPResourceReader();
  614.                 ocspValidator = new OCSPValidatorImpl(lb, store, trustStoreCrls, ocspPolicy, ocspResourceReader);
  615.                 if(ocspValidator!=null) {
  616.                     OCSPValidatorImpl gOcspValidator = (OCSPValidatorImpl) ocspValidator;
  617.                     if(gOcspValidator.getOcspConfig()!=null) {
  618.                         crlByOcsp = gOcspValidator.getOcspConfig().isCrl();
  619.                     }
  620.                 }
  621.             }
  622.             
  623.             List<String> crlList = null;
  624.             if(trustStoreCrls!=null && StringUtils.isNotEmpty(trustStoreCrls)) { 
  625.                 crlList = CRLCertstore.readCrlPaths(trustStoreCrls);
  626.             }
  627.             if(crlList!=null && !crlList.isEmpty()) {
  628.                 for (String path : crlList) {
  629.                     File f = new File(path);
  630.                     if(!f.exists() || !f.canRead()) {
  631.                         
  632.                         /** String identita = CostantiLabel.CRL+" '"+path+"'"; */
  633.                         String identita = CostantiLabel.CRL;
  634.                         if(addCertificateDetails) {
  635.                             identita = CostantiLabel.CRL+" '"+path+"'";
  636.                         }
  637.                         String errorDetails = identita;
  638.                         if(!addCertificateDetails) {
  639.                             errorDetails = errorDetails + " '"+
  640.                                     //f.getAbsolutePath()+  // nel caso di path relativo viene visualizzato un PATH basato sul bin di wildfly ed e' forviante
  641.                                     path+
  642.                                     "'";
  643.                         }
  644.                         errorDetails = errorDetails + (!f.exists() ? NOT_EXISTS_STRING : CANNOT_READ_STRING); 
  645.                         
  646.                         CertificateCheck esito = new CertificateCheck();
  647.                         esito.setStatoCheck(StatoCheck.ERROR);
  648.                         esito.addError(identita, errorDetails, storeDetails);
  649.                         return esito;
  650.                     }                   
  651.                 }
  652.                 
  653.                 if(!crlByOcsp) {
  654.                     crls = new CRLCertstore(trustStoreCrls);
  655.                 }
  656.             }
  657.         }
  658.         
  659.         CertificateCheck esito = new CertificateCheck();
  660.         boolean error = false;
  661.         boolean warning = false;
  662.         
  663.         List<String> aliasesForCheck = null;
  664.         
  665.         if(keystore) {
  666.             
  667.             List<String> alias = new ArrayList<>();
  668.             if(aliasKey!=null) {
  669.                 alias.add(aliasKey);
  670.             }
  671.             else {
  672.                 try {
  673.                     Enumeration<String> aliases = store.aliases();
  674.                     while (aliases.hasMoreElements()) {
  675.                         String aliasCheck = aliases.nextElement();
  676.                         if(store.getKeystore().isKeyEntry(aliasCheck)) {
  677.                             alias.add(aliasCheck);
  678.                         }
  679.                     }
  680.                 }catch(Exception e) {
  681.                     throw new UtilsException(e.getMessage(),e);
  682.                 }
  683.             }
  684.             if(alias.isEmpty()) {
  685.                 esito = new CertificateCheck();
  686.                 esito.setStatoCheck(StatoCheck.ERROR);
  687.                 esito.addError(storePath, "Nel "+CostantiLabel.KEYSTORE+" non sono presenti chiavi private", storeDetails);
  688.                 return esito;
  689.             }
  690.             
  691.             aliasesForCheck = alias;
  692.             
  693.         }
  694.         else {
  695.             
  696.             List<String> alias = new ArrayList<>();
  697.             if(aliasKey!=null) {
  698.                 alias.add(aliasKey);
  699.             }
  700.             else {
  701.                 Enumeration<String> aliases = store.aliases();
  702.                 while (aliases.hasMoreElements()) {
  703.                     String aliasCheck = aliases.nextElement();
  704.                     alias.add(aliasCheck);
  705.                 }
  706.             }
  707.             
  708.             if(alias.isEmpty()) {
  709.                 esito = new CertificateCheck();
  710.                 esito.setStatoCheck(StatoCheck.ERROR);
  711.                 esito.addError(storePath, "Nel "+CostantiLabel.TRUSTSTORE+" non sono presenti certificati", storeDetails);
  712.                 return esito;
  713.             }
  714.             
  715.             aliasesForCheck = alias;
  716.         }
  717.         
  718.         List<Certificate> listCertificate = new ArrayList<>();
  719.         if(aliasesForCheck!=null && !aliasesForCheck.isEmpty()) {
  720.             for (String aliasVerify : aliasesForCheck) {
  721.                 
  722.                 boolean secret = KeystoreType.JCEKS.getNome().equalsIgnoreCase(store.getKeystoreType());
  723.                 
  724.                 java.security.cert.X509Certificate cert = (java.security.cert.X509Certificate) store.getCertificate(aliasVerify);
  725.                 SecretKey secretKey = null;
  726.                 if(cert==null && secret && store.existsAlias(aliasKey)) {
  727.                     // provo a vedere se si tratta di una chiave segreta
  728.                     String errorKey = null;
  729.                     try {
  730.                         secretKey = store.getSecretKey(aliasVerify, passwordKey);
  731.                     }catch(Exception e) {
  732.                         errorKey = e.getMessage();
  733.                     }
  734.                     if(secretKey==null) {
  735.                         esito = new CertificateCheck();
  736.                         esito.setStatoCheck(StatoCheck.ERROR);
  737.                         esito.addError(storePath, "Nel "+
  738.                                 CostantiLabel.KEYSTORE+
  739.                                 " la chiave segreta "+
  740.                                 " con alias '"+aliasVerify+"' non è accessibile"+
  741.                                 (errorKey!=null ? ": "+errorKey : ""), storeDetails);
  742.                         return esito;
  743.                     }
  744.                 }
  745.                 if(cert==null && secretKey==null) {
  746.                     esito = new CertificateCheck();
  747.                     esito.setStatoCheck(StatoCheck.ERROR);
  748.                     esito.addError(storePath, "Nel "+
  749.                             (keystore ? CostantiLabel.KEYSTORE : CostantiLabel.TRUSTSTORE)+
  750.                             " non è presente "+
  751.                             (keystore ? "una coppia di chiavi" : "un certificato")+
  752.                             " con alias '"+aliasVerify+"'", storeDetails);
  753.                     return esito;
  754.                 }
  755.                 
  756.                 if(keystore && secretKey==null) {
  757.                     PrivateKey privateKey = null;
  758.                     String errorKey = null;
  759.                     try {
  760.                         privateKey = store.getPrivateKey(aliasVerify, passwordKey);
  761.                     }catch(Exception e) {
  762.                         errorKey = e.getMessage();
  763.                     }
  764.                     if(privateKey==null) {
  765.                         esito = new CertificateCheck();
  766.                         esito.setStatoCheck(StatoCheck.ERROR);
  767.                         esito.addError(storePath, "Nel "+
  768.                                 CostantiLabel.KEYSTORE+
  769.                                 " la chiave "+
  770.                                 " con alias '"+aliasVerify+"' non è accessibile"+
  771.                                 (errorKey!=null ? ": "+errorKey : ""), storeDetails);
  772.                         return esito;
  773.                     }
  774.                 }
  775.                 
  776.                 if(secretKey==null) {
  777.                     java.security.cert.Certificate[] baseCertChain = store.getCertificateChain(aliasVerify);
  778.                     List<java.security.cert.X509Certificate> certChain = null;
  779.                     if(baseCertChain!=null && baseCertChain.length>0) {
  780.                         for (int i = 0; i < baseCertChain.length; i++) {
  781.                             java.security.cert.Certificate check = baseCertChain[i];
  782.                             if(check instanceof X509Certificate) {
  783.                                 if(certChain==null) {
  784.                                     certChain = new ArrayList<>();
  785.                                 }
  786.                                 certChain.add((X509Certificate) check);
  787.                             }
  788.                         }
  789.                     }
  790.                                     
  791.                     Certificate certificate = new Certificate(aliasVerify, 
  792.                             cert, 
  793.                             certChain );
  794.                     listCertificate.add(certificate);
  795.                 }
  796.             }
  797.         }
  798.                 
  799.         if(listCertificate!=null && !listCertificate.isEmpty()) {
  800.             for (Certificate certificate : listCertificate) {   
  801.                 
  802.                 String aliasVerify = certificate.getCertificate().getName();
  803.                 String identita = "Certificato '"+aliasVerify+"'";
  804.                 
  805.                 String aliasDetails = "";
  806.                 if(!storeDetails.contains(CostantiLabel.KEY_ALIAS+separator+aliasVerify)) {
  807.                     aliasDetails = (addCertificateDetails ? newLine : "") + 
  808.                             CostantiLabel.ALIAS+separator+aliasVerify;
  809.                 }
  810.                 String certificateDetails = CertificateUtils.toString(certificate, separator, newLine);
  811.                 certificateDetails = storeDetails +
  812.                         aliasDetails +
  813.                         newLine +
  814.                         certificateDetails;
  815.                 boolean check = true;
  816.                 try {
  817.                     if(keystore || crls==null) {
  818.                         certificate.getCertificate().checkValid();
  819.                     }
  820.                     else {
  821.                         certificate.getCertificate().checkValid(crls.getCertStore(), store);
  822.                     }
  823.                     if(ocspValidator!=null) {
  824.                         ocspValidator.valid(certificate.getCertificate().getCertificate());
  825.                     }
  826.                 }catch(Exception t) {
  827.                     String msgErrore = "Certificato non valido: "+t.getMessage();
  828.                     error = true;
  829.                     esito.addError(identita, msgErrore, certificateDetails);
  830.                     /** check = false; */
  831.                     continue;
  832.                 }
  833.                                     
  834.                 if(check && certificate.getCertificateChain()!=null && !certificate.getCertificateChain().isEmpty()) {
  835.                     for (CertificateInfo caChain : certificate.getCertificateChain()) {
  836.                         String hexCaChain = caChain.getSerialNumberHex();
  837.                         String credenzialeCaChain = "(CN:"+caChain.getSubject().getCN()+SERIAL_NUMBER_STRING+hexCaChain+")";
  838.                         try {
  839.                             if(keystore || crls==null) {
  840.                                 caChain.checkValid();
  841.                             }
  842.                             else {
  843.                                 caChain.checkValid(crls.getCertStore(), store);
  844.                             }
  845.                             // La validazione della catena viene effettuata direttamente dal ocsp validator se previsto dalla policy
  846. /**                         if(ocspValidator!=null) {
  847. //                              ocspValidator.valid(certificate.getCertificate().getCertificate());
  848. //                          }*/
  849.                         }catch(Exception t) {
  850.                             check = false;
  851.                             String msgErrore = ("Un certificato della catena "+credenzialeCaChain+getSuffixCertificateNotValid(t));
  852.                             error = true;
  853.                             esito.addError(identita, msgErrore, certificateDetails);
  854.                         }
  855.                     }
  856.                 }
  857.                 
  858.                 if(check && sogliaWarningGiorni>0 &&
  859.                     certificate.getCertificate().getNotAfter()!=null) {
  860.                     long expire = certificate.getCertificate().getNotAfter().getTime();
  861.                     long now = DateManager.getTimeMillis();
  862.                     long diff = expire - now;
  863.                     long soglia = (1000l*60l*60l*24l) * (sogliaWarningGiorni);
  864.                     /**System.out.println("=======================");
  865.                     //System.out.println("SUBJECT ["+certificate.getCertificate().getCertificate().getSubjectDN().getName()+"]");
  866.                     //System.out.println("NOT AFTER ["+certificate.getCertificate().getNotAfter()+"]");
  867.                     //System.out.println("SOGLIA ["+sogliaWarningGiorni+"]");
  868.                     //System.out.println("DEXP ["+expire+"]");
  869.                     //System.out.println("DNOW ["+now+"]");
  870.                     //System.out.println("DIFF ["+diff+"]");
  871.                     //System.out.println("SOGLIATR ["+soglia+"]");*/
  872.                     if(diff<soglia) {
  873.                         String msgErrore = "Certificato prossima alla scadenza ("+sogliaWarningGiorni+" giorni): "+sdf.format(certificate.getCertificate().getNotAfter());
  874.                         warning = true;
  875.                         esito.addWarning(identita, msgErrore, certificateDetails);
  876.                     }
  877.                 }
  878.                 
  879.             }
  880.         }
  881.                 
  882.         if(error) {
  883.             esito.setStatoCheck(StatoCheck.ERROR);
  884.         }
  885.         else if(warning) {
  886.             esito.setStatoCheck(StatoCheck.WARN);
  887.         }
  888.         else {
  889.             esito.setStatoCheck(StatoCheck.OK);
  890.         }
  891.         return esito;

  893.     }
  894.     
  895.     
  896.     public static CertificateCheck checkSingleCertificate(String storeDetails, byte[] bytesCert, 
  897.             int sogliaWarningGiorni, 
  898.             String separator, String newLine) throws UtilsException{
  899.         
  900.         SimpleDateFormat sdf = new SimpleDateFormat(FORMAT_DATE_CERTIFICATE);
  901.         
  902.         
  903.         CertificateCheck esito = new CertificateCheck();
  904.         boolean error = false;
  905.         boolean warning = false;
  906.         
  907.         Certificate certificate = ArchiveLoader.load(bytesCert);        
  908.         
  909.         String identita = "Certificato";
  910.         
  911.         String certificateDetails = storeDetails +
  912.                 newLine +
  913.                 CertificateUtils.toString(certificate, separator, newLine);
  914.         boolean check = true;
  915.         try {
  916.             certificate.getCertificate().checkValid();
  917.         }catch(Exception t) {
  918.             check = false;
  919.             String msgErrore = "Certificato non valido: "+t.getMessage();
  920.             error = true;
  921.             esito.addError(identita, msgErrore, certificateDetails);
  922.         }
  923.                             
  924.         if(check && certificate.getCertificateChain()!=null && !certificate.getCertificateChain().isEmpty()) {
  925.             for (CertificateInfo caChain : certificate.getCertificateChain()) {
  926.                 String hexCaChain = caChain.getSerialNumberHex();
  927.                 String credenzialeCaChain = "(CN:"+caChain.getSubject().getCN()+SERIAL_NUMBER_STRING+hexCaChain+")";
  928.                 try {
  929.                     caChain.checkValid();
  930.                 }catch(Exception t) {
  931.                     check = false;
  932.                     String msgErrore = ("Un certificato della catena "+credenzialeCaChain+getSuffixCertificateNotValid(t));
  933.                     error = true;
  934.                     esito.addError(identita, msgErrore, certificateDetails);
  935.                 }
  936.             }
  937.         }
  938.         
  939.         if(check && sogliaWarningGiorni>0 &&
  940.             certificate.getCertificate().getNotAfter()!=null) {
  941.             long expire = certificate.getCertificate().getNotAfter().getTime();
  942.             long now = DateManager.getTimeMillis();
  943.             long diff = expire - now;
  944.             long soglia = (1000l*60l*60l*24l) * (sogliaWarningGiorni);
  945.             /**System.out.println("=======================");
  946.             //System.out.println("SUBJECT ["+certificate.getCertificate().getCertificate().getSubjectDN().getName()+"]");
  947.             //System.out.println("NOT AFTER ["+certificate.getCertificate().getNotAfter()+"]");
  948.             //System.out.println("SOGLIA ["+sogliaWarningGiorni+"]");
  949.             //System.out.println("DEXP ["+expire+"]");
  950.             //System.out.println("DNOW ["+now+"]");
  951.             //System.out.println("DIFF ["+diff+"]");
  952.             //System.out.println("SOGLIATR ["+soglia+"]");*/
  953.             if(diff<soglia) {
  954.                 String msgErrore = "Certificato prossima alla scadenza ("+sogliaWarningGiorni+" giorni): "+sdf.format(certificate.getCertificate().getNotAfter());
  955.                 warning = true;
  956.                 esito.addWarning(identita, msgErrore, certificateDetails);
  957.             }
  958.         }
  959.             
  960.         if(error) {
  961.             esito.setStatoCheck(StatoCheck.ERROR);
  962.         }
  963.         else if(warning) {
  964.             esito.setStatoCheck(StatoCheck.WARN);
  965.         }
  966.         else {
  967.             esito.setStatoCheck(StatoCheck.OK);
  968.         }
  969.         return esito;

  971.     }
  972.     
  973.     
  974.     
  975.     public static CertificateCheck checkKeyPair(String privateKeyPath, byte[] privateKey, 
  976.             String publicKeyPath, byte[] publicKey, String passwordKey, String algorithm, IBYOKUnwrapManager byokUnwrapManager,
  977.             boolean addCertificateDetails, String separator, String newLine) throws UtilsException{
  978.         
  979.         String storeDetails = null;
  980.         if(addCertificateDetails) {
  981.             storeDetails = toStringKeyPair(privateKeyPath, publicKeyPath,
  982.                     (byokUnwrapManager!=null ? byokUnwrapManager.getPolicy() : null),
  983.                     separator, newLine);
  984.         }
  985.         
  986.         return checkKeyPairEngine(true,
  987.                 storeDetails, privateKey, publicKey, passwordKey, algorithm, byokUnwrapManager,
  988.                 addCertificateDetails);
  989.     }
  990.     public static CertificateCheck checkKeyPair(boolean classpathSupported, String privateKey, String publicKey, String passwordKey, String algorithm, IBYOKUnwrapManager byokUnwrapManager,
  991.             boolean addCertificateDetails, String separator, String newLine) throws UtilsException{
  992.         return checkKeyPairEngine(true,
  993.                 classpathSupported, privateKey, publicKey, passwordKey, algorithm, byokUnwrapManager,
  994.                 addCertificateDetails, separator, newLine);
  995.     }
  996.     public static String toStringKeyPair(KeystoreParams params,
  997.             String separator, String newLine) {
  998.         return toStringKeyPair(params.getPath(), params.getKeyPairPublicKeyPath(), params.getByokPolicy(),
  999.                 separator, newLine);
  1000.     }
  1001.     private static String toStringKeyPair(String privateKey, String publicKey, String byokPolicy,
  1002.             String separator, String newLine) {
  1003.         
  1004.         StringBuilder sb = new StringBuilder();
  1005.         
  1006.         sb.append(CostantiLabel.KEY_PAIR);
  1007.         sb.append(separator);
  1008.         sb.append("private:");
  1009.         sb.append(privateKey);
  1010.         sb.append(" ");
  1011.         sb.append("public:");
  1012.         sb.append(publicKey);
  1013.         
  1014.         if(byokPolicy!=null) {
  1015.             sb.append(newLine);
  1016.             sb.append(CostantiLabel.BYOK_POLICY);
  1017.             sb.append(separator);
  1018.             sb.append(byokPolicy);
  1019.         }
  1020.         
  1021.         return sb.toString();
  1022.     }
  1023.     
  1024.     public static CertificateCheck checkPublicKey(String publicKeyPath, byte[] publicKey, String algorithm,
  1025.             boolean addCertificateDetails, String separator, String newLine) throws UtilsException{
  1026.         
  1027.         String storeDetails = null;
  1028.         if(addCertificateDetails) {
  1029.             storeDetails = toStringPublicKey(publicKeyPath, separator, newLine);
  1030.         }
  1031.         
  1032.         return checkKeyPairEngine(false,
  1033.                 storeDetails, null, publicKey, null, algorithm, null,
  1034.                 addCertificateDetails);
  1035.     }
  1036.     public static CertificateCheck checkPublicKey(boolean classpathSupported, String publicKey, String algorithm,
  1037.             boolean addCertificateDetails, String separator, String newLine) throws UtilsException{
  1038.         return checkKeyPairEngine(false,
  1039.                 classpathSupported, null, publicKey, null, algorithm, null,
  1040.                 addCertificateDetails, separator, newLine);
  1041.     }   
  1042.     public static String toStringPublicKey(KeystoreParams params,
  1043.             String separator, String newLine) {
  1044.         return toStringPublicKey(params.getPath(), 
  1045.                 separator, newLine);
  1046.     }
  1047.     private static String toStringPublicKey(String publicKey,
  1048.             String separator, String newLine) {
  1049.         
  1050.         if(newLine!=null) {
  1051.             // nop
  1052.         }
  1053.         
  1054.         StringBuilder sb = new StringBuilder();
  1055.         
  1056.         sb.append(CostantiLabel.PUBLIC_KEY);
  1057.         sb.append(separator);
  1058.         sb.append(publicKey);
  1059.         
  1060.         return sb.toString();
  1061.     }
  1062.     
  1063.     
  1064.     
  1065.     
  1066.     private static CertificateCheck checkKeyPairEngine(boolean isKeyPair,
  1067.             boolean classpathSupported, String privateKey, String publicKey, String passwordKey, String algorithm, IBYOKUnwrapManager byokUnwrapManager,
  1068.             boolean addCertificateDetails, String separator, String newLine) throws UtilsException{
  1069.         
  1070.         String storeDetails = null;
  1071.         if(addCertificateDetails) {
  1072.             if(isKeyPair) {
  1073.                 storeDetails = toStringKeyPair(privateKey, publicKey, 
  1074.                         (byokUnwrapManager!=null ? byokUnwrapManager.getPolicy() : null),
  1075.                         separator, newLine);
  1076.             }
  1077.             else {
  1078.                 storeDetails = toStringPublicKey(publicKey, separator, newLine);
  1079.             }
  1080.         }
  1081.         
  1082.         
  1083.         // PRIVATE KEY
  1084.         
  1085.         byte[] privateKeyBytes = null;
  1086.         if(isKeyPair) {
  1087.             File f = new File(privateKey);
  1088.             boolean exists = f.exists();
  1089.             boolean inClasspath = false;
  1090.             if(!exists && classpathSupported) {
  1091.                 String uri = privateKey;
  1092.                 if(!privateKey.startsWith("/")) {
  1093.                     uri = "/" + uri;    
  1094.                 }
  1095.                 try {
  1096.                     try( InputStream is = CertificateUtils.class.getResourceAsStream(uri); ){
  1097.                         exists = (is!=null);
  1098.                         if(exists) {
  1099.                             inClasspath = true;
  1100.                             privateKeyBytes = Utilities.getAsByteArray(is);
  1101.                         }
  1102.                     }
  1103.                 }catch(Exception e) {
  1104.                     throw new UtilsException(e.getMessage(),e);
  1105.                 }
  1106.             }
  1107.             if(!exists || (!inClasspath && !f.canRead())) {
  1108.                 
  1109.                 String errorDetails = CostantiLabel.PRIVATE_KEY;
  1110.                 if(!addCertificateDetails) {
  1111.                     errorDetails = errorDetails + " '"+
  1112.                             //f.getAbsolutePath()+  // nel caso di path relativo viene visualizzato un PATH basato sul bin di wildfly ed e' forviante
  1113.                             privateKey+
  1114.                             "'";
  1115.                 }
  1116.                 errorDetails = errorDetails + (!exists ? NOT_EXISTS_STRING : CANNOT_READ_STRING); 
  1117.                 
  1118.                 CertificateCheck esito = new CertificateCheck();
  1119.                 esito.setStatoCheck(StatoCheck.ERROR);
  1120.                 esito.addError(privateKey, errorDetails, storeDetails);
  1121.                 return esito;
  1122.             }
  1123.             if(!inClasspath) {
  1124.                 try {
  1125.                     privateKeyBytes = FileSystemUtilities.readBytesFromFile(f);
  1126.                 }catch(Exception e) {
  1127.                     throw new UtilsException(e.getMessage(),e);
  1128.                 }
  1129.             }
  1130.         }
  1131.         
  1132.         // PUBLIC KEY
  1133.         
  1134.         byte[] publicKeyBytes = null;
  1135.         File f = new File(publicKey);
  1136.         boolean exists = f.exists();
  1137.         boolean inClasspath = false;
  1138.         if(!exists && classpathSupported) {
  1139.             String uri = publicKey;
  1140.             if(!publicKey.startsWith("/")) {
  1141.                 uri = "/" + uri;    
  1142.             }
  1143.             try {
  1144.                 try( InputStream is = CertificateUtils.class.getResourceAsStream(uri); ){
  1145.                     exists = (is!=null);
  1146.                     if(exists) {
  1147.                         inClasspath = true;
  1148.                         publicKeyBytes = Utilities.getAsByteArray(is);
  1149.                     }
  1150.                 }
  1151.             }catch(Exception e) {
  1152.                 throw new UtilsException(e.getMessage(),e);
  1153.             }
  1154.         }
  1155.                 
  1156.         if(!exists || (!inClasspath && !f.canRead())) {
  1157.             
  1158.             String errorDetails = CostantiLabel.PUBLIC_KEY;
  1159.             if(!addCertificateDetails) {
  1160.                 errorDetails = errorDetails + " '"+
  1161.                         //f.getAbsolutePath()+  // nel caso di path relativo viene visualizzato un PATH basato sul bin di wildfly ed e' forviante
  1162.                         publicKey+
  1163.                         "'";
  1164.             }
  1165.             errorDetails = errorDetails + (!exists ? NOT_EXISTS_STRING : CANNOT_READ_STRING); 
  1166.             
  1167.             CertificateCheck esito = new CertificateCheck();
  1168.             esito.setStatoCheck(StatoCheck.ERROR);
  1169.             esito.addError(publicKey, errorDetails, storeDetails);
  1170.             return esito;
  1171.         }
  1172.         if(!inClasspath) {
  1173.             try {
  1174.                 publicKeyBytes = FileSystemUtilities.readBytesFromFile(f);
  1175.             }catch(Exception e) {
  1176.                 throw new UtilsException(e.getMessage(),e);
  1177.             }
  1178.         }
  1179.         
  1180.         return checkKeyPairEngine(isKeyPair,
  1181.                 storeDetails, privateKeyBytes, publicKeyBytes, passwordKey, algorithm, byokUnwrapManager,
  1182.                 addCertificateDetails);
  1183.     }
  1184.     private static CertificateCheck checkKeyPairEngine(boolean isKeyPair,
  1185.             String storeDetails, byte[] privateKey, byte[] publicKey, String passwordKey, String algorithm, IBYOKUnwrapManager byokUnwrapManager,
  1186.             boolean addCertificateDetails) throws UtilsException{
  1187.                 
  1188.         KeyUtils keyUtils = null;
  1189.         try {
  1190.             keyUtils = KeyUtils.getInstance(algorithm);
  1191.         }catch(Exception t) {
  1192.             String errorDetails = "KeyAlgorithm";
  1193.             if(!addCertificateDetails) {
  1194.                 errorDetails = errorDetails + " '"+
  1195.                         //f.getAbsolutePath()+  // nel caso di path relativo viene visualizzato un PATH basato sul bin di wildfly ed e' forviante
  1196.                         algorithm+
  1197.                         "'";
  1198.             }
  1199.             errorDetails = errorDetails + " unknown: "+t.getMessage(); 
  1200.             
  1201.             CertificateCheck esito = new CertificateCheck();
  1202.             esito.setStatoCheck(StatoCheck.ERROR);
  1203.             esito.addError(algorithm, errorDetails, storeDetails);
  1204.             return esito;
  1205.         }
  1206.         
  1207.         if(isKeyPair) {
  1208.             try {
  1209.                 if(byokUnwrapManager!=null) {
  1210.                     privateKey = byokUnwrapManager.unwrap(privateKey);
  1211.                 }
  1212.                 if(passwordKey!=null) {
  1213.                     keyUtils.getPrivateKey(privateKey, passwordKey);
  1214.                 }
  1215.                 else {
  1216.                     keyUtils.getPrivateKey(privateKey);
  1217.                 }
  1218.             }catch(Exception t) {
  1219.                 String errorDetails = READING_PREFIX_STRING+ CostantiLabel.PRIVATE_KEY+getSuffixFailed(t);
  1220.                 CertificateCheck esito = new CertificateCheck();
  1221.                 esito.setStatoCheck(StatoCheck.ERROR);
  1222.                 esito.addError(CostantiLabel.PRIVATE_KEY, errorDetails, storeDetails);
  1223.                 return esito;
  1224.             }
  1225.         }
  1226.         
  1227.         try {
  1228.             keyUtils.getPublicKey(publicKey);
  1229.         }catch(Exception t) {
  1230.             String errorDetails = READING_PREFIX_STRING+ CostantiLabel.PUBLIC_KEY+getSuffixFailed(t);
  1231.             CertificateCheck esito = new CertificateCheck();
  1232.             esito.setStatoCheck(StatoCheck.ERROR);
  1233.             esito.addError(CostantiLabel.PUBLIC_KEY, errorDetails, storeDetails);
  1234.             return esito;
  1235.         }
  1236.         
  1237.         CertificateCheck esito = new CertificateCheck();
  1238.         esito.setStatoCheck(StatoCheck.OK);
  1239.         return esito;
  1240.     }
  1241.     
  1242.     
  1243.     
  1244.     
  1245.     
  1246.     public static CertificateCheck checkKeystoreJWKs(boolean classpathSupported, String jwksPath, String keyAlias, IBYOKUnwrapManager byokUnwrapManager, 
  1247.             boolean addCertificateDetails, String separator, String newLine) throws UtilsException{
  1248.         return checkJWKsEngine(true,
  1249.                 classpathSupported, jwksPath, keyAlias,
  1250.                 byokUnwrapManager,
  1251.                 addCertificateDetails, separator, newLine);
  1252.     }
  1253.     public static CertificateCheck checkKeystoreJWKs(String jwksPath, String jwks, String keyAlias, IBYOKUnwrapManager byokUnwrapManager, 
  1254.             boolean addCertificateDetails, String separator, String newLine) throws UtilsException{
  1255.         
  1256.         String storeDetails = null;
  1257.         if(addCertificateDetails) {
  1258.             storeDetails = toStringJWKs(true, jwksPath, keyAlias,
  1259.                     (byokUnwrapManager!=null ? byokUnwrapManager.getPolicy() : null),
  1260.                     separator, newLine);
  1261.         }
  1262.         
  1263.         return checkJWKsEngine(false, 
  1264.                 storeDetails, jwks, keyAlias, byokUnwrapManager);
  1265.     }
  1266.     public static CertificateCheck checkTruststoreJWKs(boolean classpathSupported, String jwksPath, String keyAlias, 
  1267.             boolean addCertificateDetails, String separator, String newLine) throws UtilsException{
  1268.         return checkJWKsEngine(false,
  1269.                 classpathSupported, jwksPath, keyAlias, null,
  1270.                 addCertificateDetails, separator, newLine);
  1271.     }
  1272.     public static CertificateCheck checkTruststoreJWKs(String jwksPath, String jwks, String keyAlias, 
  1273.             boolean addCertificateDetails, String separator, String newLine) throws UtilsException{
  1274.         
  1275.         String storeDetails = null;
  1276.         if(addCertificateDetails) {
  1277.             storeDetails = toStringJWKs(false, jwksPath, keyAlias,
  1278.                     null,
  1279.                     separator, newLine);
  1280.         }
  1281.         
  1282.         return checkJWKsEngine(false, 
  1283.                 storeDetails, jwks, keyAlias, null);
  1284.     }
  1285.     private static CertificateCheck checkJWKsEngine(boolean keystore,
  1286.             boolean classpathSupported, String jwksPath, String keyAlias, IBYOKUnwrapManager byokUnwrapManager,
  1287.             boolean addCertificateDetails, String separator, String newLine) throws UtilsException{
  1288.         
  1289.         String storeDetails = null;
  1290.         if(addCertificateDetails) {
  1291.             storeDetails = toStringJWKs(keystore, jwksPath, keyAlias,
  1292.                     (byokUnwrapManager!=null ? byokUnwrapManager.getPolicy() : null),
  1293.                     separator, newLine);
  1294.         }
  1295.                 
  1296.         String jwks = null;
  1297.         File f = new File(jwksPath);
  1298.         boolean exists = f.exists();
  1299.         boolean inClasspath = false;
  1300.         if(!exists && classpathSupported) {
  1301.             String uri = jwksPath;
  1302.             if(!jwksPath.startsWith("/")) {
  1303.                 uri = "/" + uri;    
  1304.             }
  1305.             try {
  1306.                 try( InputStream is = CertificateUtils.class.getResourceAsStream(uri); ){
  1307.                     exists = (is!=null);
  1308.                     if(exists) {
  1309.                         inClasspath = true;
  1310.                         jwks = Utilities.getAsString(is, Charset.UTF_8.getValue());
  1311.                     }
  1312.                 }
  1313.             }catch(Exception e) {
  1314.                 throw new UtilsException(e.getMessage(),e);
  1315.             }
  1316.         }
  1317.                 
  1318.         if(!exists || (!inClasspath && !f.canRead())) {
  1319.             
  1320.             String errorDetails = keystore ? CostantiLabel.KEYSTORE : CostantiLabel.TRUSTSTORE;
  1321.             if(!addCertificateDetails) {
  1322.                 errorDetails = errorDetails + " '"+
  1323.                         //f.getAbsolutePath()+  // nel caso di path relativo viene visualizzato un PATH basato sul bin di wildfly ed e' forviante
  1324.                         jwksPath+
  1325.                         "'";
  1326.             }
  1327.             errorDetails = errorDetails + (!exists ? NOT_EXISTS_STRING : CANNOT_READ_STRING); 
  1328.             
  1329.             CertificateCheck esito = new CertificateCheck();
  1330.             esito.setStatoCheck(StatoCheck.ERROR);
  1331.             esito.addError(jwksPath, errorDetails, storeDetails);
  1332.             return esito;
  1333.         }
  1334.         if(!inClasspath) {
  1335.             try {
  1336.                 jwks = FileSystemUtilities.readFile(f);
  1337.             }catch(Exception e) {
  1338.                 throw new UtilsException(e.getMessage(),e);
  1339.             }
  1340.         }
  1341.         
  1342.         return checkJWKsEngine(keystore, 
  1343.                 storeDetails, jwks, keyAlias, byokUnwrapManager);
  1344.     }
  1345.     private static CertificateCheck checkJWKsEngine(boolean keystore, 
  1346.             String storeDetails,
  1347.             String jwks, String keyAlias, IBYOKUnwrapManager byokUnwrapManager) throws UtilsException{
  1348.                 
  1349.         com.nimbusds.jose.jwk.JWKSet set = null;
  1350.         try {
  1351.             if(keystore && byokUnwrapManager!=null) {
  1352.                 jwks = new String(byokUnwrapManager.unwrap(jwks.getBytes()));
  1353.             }
  1354.             JWKSet jwkset = new JWKSet(jwks);
  1355.             set = jwkset.getJWKSet();
  1356.         }catch(Exception t) {
  1357.             String errorDetails = READING_PREFIX_STRING+ (keystore ? CostantiLabel.KEYSTORE : CostantiLabel.TRUSTSTORE) +getSuffixFailed(t);
  1358.             CertificateCheck esito = new CertificateCheck();
  1359.             esito.setStatoCheck(StatoCheck.ERROR);
  1360.             esito.addError(keystore ? CostantiLabel.KEYSTORE : CostantiLabel.TRUSTSTORE, errorDetails, storeDetails);
  1361.             return esito;
  1362.         }
  1363.         
  1364.         CertificateCheck checkAlias = checkJWKsEngineKeyAlias(keyAlias, set, keystore, storeDetails);
  1365.         if(checkAlias!=null) {
  1366.             return checkAlias;
  1367.         }
  1368.         
  1369.         CertificateCheck esito = new CertificateCheck();
  1370.         esito.setStatoCheck(StatoCheck.OK);
  1371.         return esito;
  1372.     }
  1373.     private static CertificateCheck checkJWKsEngineKeyAlias(String keyAlias, com.nimbusds.jose.jwk.JWKSet set, boolean keystore, String storeDetails) {
  1374.         if(keyAlias!=null && StringUtils.isNotEmpty(keyAlias) && !"*".equals(keyAlias)) {
  1375.             try {
  1376.                 com.nimbusds.jose.jwk.JWK jwk = set.getKeyByKeyId(keyAlias);
  1377.                 if(jwk==null) {
  1378.                     throw new UtilsException("kid not exists");
  1379.                 }
  1380.             }catch(Exception t) {
  1381.                 String errorDetails = (keystore ? CostantiLabel.KEY_ALIAS : CostantiLabel.CERTIFICATE_ALIAS) +" unknown: "+t.getMessage();
  1382.                 CertificateCheck esito = new CertificateCheck();
  1383.                 esito.setStatoCheck(StatoCheck.ERROR);
  1384.                 esito.addError(keystore ? CostantiLabel.KEYSTORE : CostantiLabel.TRUSTSTORE, errorDetails, storeDetails);
  1385.                 return esito;
  1386.             }
  1387.         }
  1388.         return null;
  1389.     }
  1390.     public static String toStringKeystoreJWKs(KeystoreParams params,
  1391.             String separator, String newLine) {
  1392.         return toStringJWKs(true, params.getPath(), params.getKeyAlias(), params.getByokPolicy(),
  1393.                 separator, newLine);
  1394.     }
  1395.     public static String toStringTruststoreJWKs(KeystoreParams params,
  1396.             String separator, String newLine) {
  1397.         return toStringJWKs(false, params.getPath(), params.getKeyAlias(), null,
  1398.                 separator, newLine);
  1399.     }
  1400.     private static String toStringJWKs(boolean keystore, String jwksPath, String keyAlias, String byokPolicy,
  1401.             String separator, String newLine) {
  1402.         
  1403.         StringBuilder sb = new StringBuilder();
  1404.         
  1405.         sb.append(keystore? CostantiLabel.KEYSTORE : CostantiLabel.TRUSTSTORE);
  1406.         sb.append(separator);
  1407.         sb.append(CostantiLabel.JWKS);
  1408.         sb.append(" ");
  1409.         sb.append(jwksPath);
  1410.         
  1411.         if(keyAlias!=null) {
  1412.             sb.append(newLine);
  1413.             if(keystore) {
  1414.                 sb.append(CostantiLabel.KEY_ALIAS);
  1415.             }
  1416.             else {
  1417.                 sb.append(CostantiLabel.CERTIFICATE_ALIAS);
  1418.             }
  1419.             sb.append(separator);
  1420.             sb.append(keyAlias);
  1421.         }
  1422.         
  1423.         if(byokPolicy!=null) {
  1424.             sb.append(newLine);
  1425.             sb.append(CostantiLabel.BYOK_POLICY);
  1426.             sb.append(separator);
  1427.             sb.append(byokPolicy);
  1428.         }
  1429.         
  1430.         return sb.toString();
  1431.     }
  1432. }
Created with JaCoCo 0.8.8.202204050719