AutenticazioneSsl.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.  */



  23. package org.openspcoop2.pdd.core.autenticazione.pa;

  25. import java.security.cert.CertStore;
  26. import java.util.ArrayList;
  27. import java.util.List;

  29. import org.openspcoop2.core.commons.CoreException;
  30. import org.openspcoop2.core.config.Proprieta;
  31. import org.openspcoop2.core.id.IDServizioApplicativo;
  32. import org.openspcoop2.core.id.IDSoggetto;
  33. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  34. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  35. import org.openspcoop2.pdd.config.CostantiProprieta;
  36. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  37. import org.openspcoop2.pdd.core.autenticazione.AutenticazioneException;
  38. import org.openspcoop2.pdd.core.autenticazione.WWWAuthenticateConfig;
  39. import org.openspcoop2.pdd.core.credenziali.Credenziali;
  40. import org.openspcoop2.pdd.core.keystore.GestoreKeystoreCaching;
  41. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  42. import org.openspcoop2.protocol.engine.ConfigurazioneFiltroServiziApplicativi;
  43. import org.openspcoop2.protocol.engine.constants.Costanti;
  44. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  45. import org.openspcoop2.protocol.sdk.constants.ErroriCooperazione;
  46. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  47. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  48. import org.openspcoop2.security.keystore.cache.GestoreOCSPResource;
  49. import org.openspcoop2.security.keystore.cache.GestoreOCSPValidator;
  50. import org.openspcoop2.utils.LoggerBuffer;
  51. import org.openspcoop2.utils.UtilsMultiException;
  52. import org.openspcoop2.utils.certificate.CertificateInfo;
  53. import org.openspcoop2.utils.certificate.KeyStore;
  54. import org.openspcoop2.utils.transport.http.IOCSPValidator;
  55. import org.openspcoop2.utils.transport.http.OCSPResponseException;

  57. /**
  58.  * Classe che implementa una autenticazione BASIC.
  59.  *
  60.  * @author Andrea Poli (apoli@link.it)
  61.  * @author $Author$
  62.  * @version $Rev$, $Date$
  63.  */

  65. public class AutenticazioneSsl extends AbstractAutenticazioneBase {

  67.     private boolean logError = true;
  68.     @Override
  69.     public void setLogError(boolean logError) {
  70.         this.logError = logError;
  71.     }
  72.     
  73.     @Override
  74.     public EsitoAutenticazionePortaApplicativa process(DatiInvocazionePortaApplicativa datiInvocazione) throws AutenticazioneException{

  76.         EsitoAutenticazionePortaApplicativa esito = new EsitoAutenticazionePortaApplicativa();
  77.         
  78.         if(datiInvocazione==null) {
  79.             throw new AutenticazioneException("Param datiInvocazione is null");
  80.         }
  81.         
  82.         OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  83.         WWWAuthenticateConfig wwwAuthenticateConfig = op2Properties.getRealmAutenticazioneHttpsWWWAuthenticateConfig();
  84.         
  85.         Credenziali credenziali = datiInvocazione.getInfoConnettoreIngresso().getCredenziali();
  86.         
  87.         RequestInfo requestInfo = datiInvocazione.getRequestInfo();
  88.         
  89.         String subject = credenziali.getSubject();
  90.         String issuer = credenziali.getIssuer();
  91.         CertificateInfo certificate = null;

  93.         // Controllo credenziali fornite
  94.         if( subject==null || "".equals(subject) ){
  95.             esito.setErroreCooperazione(IntegrationFunctionError.AUTHENTICATION_CREDENTIALS_NOT_FOUND, ErroriCooperazione.AUTENTICAZIONE_FALLITA_CREDENZIALI_NON_FORNITE.getErroreCooperazione());
  96.             esito.setClientAuthenticated(false);
  97.             esito.setClientIdentified(false);
  98.             if(wwwAuthenticateConfig!=null) {
  99.                 esito.setWwwAuthenticateErrorHeader(wwwAuthenticateConfig.buildWWWAuthenticateHeaderValue_notFound());
  100.             }
  101.             return esito;
  102.         }
  103.         if(credenziali.getCertificate()!=null) {
  104.             certificate = credenziali.getCertificate().getCertificate();
  105.             
  106.             List<Proprieta> proprieta = null;
  107.             if(datiInvocazione.getPa()!=null) {
  108.                 proprieta = datiInvocazione.getPa().getProprietaList();
  109.             }
  110.             else if(datiInvocazione.getPd()!=null) {
  111.                 proprieta = datiInvocazione.getPd().getProprietaList();
  112.             }
  113.             
  114.             boolean checkValid = false;
  115.             boolean trustStore = false;
  116.             KeyStore trustStoreCertificatiX509 = null;
  117.             CertStore trustStoreCertificatiX509crls = null;
  118.             IOCSPValidator ocspValidator = null;
  119.             try {
  120.                 checkValid = CostantiProprieta.isAutenticazioneHttpsValidityCheck(proprieta, op2Properties.isAutenticazioneHttpsPortaApplicativaValidityCheck());
  121.                 trustStore = CostantiProprieta.isAutenticazioneHttpsTrustStore(proprieta, op2Properties.getAutenticazioneHttpsPortaApplicativaTruststorePath());
  122.                 if(trustStore) {
  123.                     String path = CostantiProprieta.getAutenticazioneHttpsTrustStorePath(proprieta, op2Properties.getAutenticazioneHttpsPortaApplicativaTruststorePath());
  124.                     if(path!=null) {
  125.                         try {
  126.                             String password = CostantiProprieta.getAutenticazioneHttpsTrustStorePassword(proprieta, op2Properties.getAutenticazioneHttpsPortaApplicativaTruststorePassword());
  127.                             String type = CostantiProprieta.getAutenticazioneHttpsTrustStoreType(proprieta, op2Properties.getAutenticazioneHttpsPortaApplicativaTruststoreType());
  128.                             trustStoreCertificatiX509 = GestoreKeystoreCaching.getMerlinTruststore(requestInfo, path, 
  129.                                     type, 
  130.                                     password).getTrustStore();
  131.                         }catch(Exception e){
  132.                             throw new CoreException("Errore durante la lettura del truststore indicato ("+path+"): "+e.getMessage());
  133.                         }
  134.                     }
  135.                     
  136.                     if(trustStoreCertificatiX509!=null) {
  137.                         
  138.                         String crl = CostantiProprieta.getAutenticazioneHttpsTrustStoreCRLs(proprieta, op2Properties.getAutenticazioneHttpsPortaApplicativaTruststoreCRLs());
  139.                                                 
  140.                         boolean crlByOcsp = false;
  141.                         String ocspPolicy = CostantiProprieta.getAutenticazioneHttpsTrustStoreOCSPPolicy(proprieta, op2Properties.getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy());
  142.                         if(ocspPolicy!=null) {
  143.                             LoggerBuffer lb = new LoggerBuffer();
  144.                             lb.setLogDebug(OpenSPCoop2Logger.getLoggerOpenSPCoopCore());
  145.                             lb.setLogError(OpenSPCoop2Logger.getLoggerOpenSPCoopCore());
  146.                             GestoreOCSPResource ocspResourceReader = new GestoreOCSPResource(requestInfo);
  147.                             try {
  148.                                 ocspValidator = new GestoreOCSPValidator(requestInfo, lb, 
  149.                                         trustStoreCertificatiX509,
  150.                                         crl, 
  151.                                         ocspPolicy, 
  152.                                         ocspResourceReader);
  153.                             }catch(Exception e){
  154.                                 throw new CoreException("Errore durante l'inizializzazione del gestore della policy OCSP ("+ocspPolicy+"): "+e.getMessage());
  155.                             }
  156.                             if(ocspValidator!=null) {
  157.                                 GestoreOCSPValidator gOcspValidator = (GestoreOCSPValidator) ocspValidator;
  158.                                 if(gOcspValidator.getOcspConfig()!=null) {
  159.                                     crlByOcsp = gOcspValidator.getOcspConfig().isCrl();
  160.                                 }
  161.                             }
  162.                         }
  163.                         
  164.                         if(crl!=null && !crlByOcsp) {
  165.                             try {
  166.                                 trustStoreCertificatiX509crls = GestoreKeystoreCaching.getCRLCertstore(requestInfo, crl).getCertStore();
  167.                             }catch(Exception e){
  168.                                 throw new CoreException("Errore durante la lettura delle CRLs ("+crl+"): "+e.getMessage());
  169.                             }
  170.                         }
  171.                     }
  172.                 }
  173.             }catch(Exception e) {
  174.                 if(this.logError) {
  175.                     OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("AutenticazioneSsl non riuscita",e);
  176.                 }
  177.                 esito.setErroreCooperazione(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, ErroriCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreCooperazione());
  178.                 esito.setClientIdentified(false);
  179.                 esito.setEccezioneProcessamento(e);
  180.                 return esito;
  181.             }
  182.             
  183.             if(checkValid 
  184.                     &&
  185.                     trustStoreCertificatiX509crls==null) { // altrimenti la validita' viene verificata insieme alle CRL
  186.                 try {
  187.                     certificate.checkValid();
  188.                 }catch(Exception e) {
  189.                     esito.setErroreCooperazione(IntegrationFunctionError.AUTHENTICATION_INVALID_CREDENTIALS, 
  190.                             ErroriCooperazione.AUTENTICAZIONE_FALLITA_CREDENZIALI_FORNITE_NON_CORRETTE.getErroreCredenzialiForniteNonCorrette(e.getMessage()));
  191.                     esito.setClientAuthenticated(false);
  192.                     esito.setClientIdentified(false);
  193.                     if(wwwAuthenticateConfig!=null) {
  194.                         esito.setWwwAuthenticateErrorHeader(wwwAuthenticateConfig.buildWWWAuthenticateHeaderValue_invalid());
  195.                     }
  196.                     return esito;
  197.                 }
  198.             }
  199.             
  200.             if(trustStoreCertificatiX509!=null) {
  201.                 try {
  202.                     if(certificate.isVerified(trustStoreCertificatiX509, true)==false) {
  203.                         throw new CoreException("Certificato non verificabile rispetto alle CA conosciute");
  204.                     }
  205.                     if(trustStoreCertificatiX509crls!=null) {
  206.                         try {
  207.                             certificate.checkValid(trustStoreCertificatiX509crls, trustStoreCertificatiX509);
  208.                         }catch(Throwable t) {
  209.                             throw new CoreException("Certificato non valido: "+t.getMessage());
  210.                         }
  211.                     }
  212.                 }catch(Exception e) {
  213.                     esito.setErroreCooperazione(IntegrationFunctionError.AUTHENTICATION_INVALID_CREDENTIALS, 
  214.                             ErroriCooperazione.AUTENTICAZIONE_FALLITA_CREDENZIALI_FORNITE_NON_CORRETTE.getErroreCredenzialiForniteNonCorrette(e.getMessage()));
  215.                     esito.setClientAuthenticated(false);
  216.                     esito.setClientIdentified(false);
  217.                     if(wwwAuthenticateConfig!=null) {
  218.                         esito.setWwwAuthenticateErrorHeader(wwwAuthenticateConfig.buildWWWAuthenticateHeaderValue_invalid());
  219.                     }
  220.                     return esito;
  221.                 }
  222.             }
  223.             
  224.             if(ocspValidator!=null) {
  225.                 try {
  226.                     ocspValidator.valid(certificate.getCertificate());
  227.                 }catch(Throwable t) {
  228.                     esito.setErroreCooperazione(IntegrationFunctionError.AUTHENTICATION_INVALID_CREDENTIALS, 
  229.                             ErroriCooperazione.AUTENTICAZIONE_FALLITA_CREDENZIALI_FORNITE_NON_CORRETTE.getErroreCredenzialiForniteNonCorrette(t.getMessage()));
  230.                     esito.setClientAuthenticated(false);
  231.                     esito.setClientIdentified(false);
  232.                     if(!(t instanceof OCSPResponseException)) {
  233.                         esito.setNoCache(true);
  234.                     }
  235.                     if(wwwAuthenticateConfig!=null) {
  236.                         esito.setWwwAuthenticateErrorHeader(wwwAuthenticateConfig.buildWWWAuthenticateHeaderValue_invalid());
  237.                     }
  238.                     return esito;
  239.                 }
  240.             }
  241.             
  242.         }
  243.         
  244.         // Essendoci l'identita' del chiamante, il client e' stato autenticato o da un frontend o dall'application server stesso
  245.         esito.setClientAuthenticated(true);
  246.         esito.setCredential(subject);
  247.         
  248.         IDSoggetto idSoggetto = null;
  249.         try{
  250.             RegistroServiziManager registroServiziManager = RegistroServiziManager.getInstance(datiInvocazione.getState());
  251.             List<Throwable> notFoundExceptions = new ArrayList<>();
  252.             
  253.             // NOTA: il fatto di essersi registrati come strict o come non strict è insito nella registrazione dell'applicativo
  254.             
  255.             // 1. Prima si cerca per certificato strict
  256.             if(certificate!=null) {
  257.                 try{
  258.                     idSoggetto = registroServiziManager.getIdSoggettoByCredenzialiSsl(certificate, true, null); // all registry
  259.                 }catch(DriverRegistroServiziNotFound notFound){
  260.                     notFoundExceptions.add(notFound);
  261.                 }
  262.             }
  263.             if(idSoggetto==null &&
  264.                 // 2. Poi per certificato no strict
  265.                 certificate!=null) {
  266.                 try{
  267.                     idSoggetto = registroServiziManager.getIdSoggettoByCredenzialiSsl(certificate, false, null); // all registry
  268.                 }catch(DriverRegistroServiziNotFound notFound){
  269.                     notFoundExceptions.add(notFound);
  270.                 }   
  271.             }
  272.             if(idSoggetto==null) {
  273.                 // 3. per subject/issuer
  274.                 try {
  275.                     idSoggetto = registroServiziManager.getIdSoggettoByCredenzialiSsl(subject, issuer, null); // all registry
  276.                 }catch(DriverRegistroServiziNotFound notFound){
  277.                     notFoundExceptions.add(notFound);
  278.                 }
  279.             }
  280.             if(idSoggetto==null) {
  281.                 // 4. solo per subject
  282.                 try {
  283.                     idSoggetto = registroServiziManager.getIdSoggettoByCredenzialiSsl(subject, null, null); // all registry
  284.                 }catch(DriverRegistroServiziNotFound notFound){
  285.                     notFoundExceptions.add(notFound);
  286.                 }
  287.             }
  288.             
  289.             if(idSoggetto==null && !notFoundExceptions.isEmpty()) {
  290.                 throw new UtilsMultiException(notFoundExceptions.toArray(new Throwable[1]));
  291.             }
  292.         }
  293.         catch(UtilsMultiException notFound){
  294.             if(this.logError) {
  295.                 OpenSPCoop2Logger.getLoggerOpenSPCoopCore().debug("AutenticazioneSsl non ha trovato risultati",notFound);
  296.             }
  297.         }
  298.         catch(Exception e){
  299.             if(this.logError) {
  300.                 OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("AutenticazioneSsl non riuscita",e);
  301.             }
  302.             esito.setErroreCooperazione(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, ErroriCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreCooperazione());
  303.             esito.setClientIdentified(false);
  304.             esito.setEccezioneProcessamento(e);
  305.             return esito;
  306.         }
  307.         
  308.         IDServizioApplicativo idServizioApplicativo = null;
  309.         try {
  310.             if(idSoggetto==null && this.getProtocolFactory().createProtocolConfiguration().isSupportoAutenticazioneApplicativiErogazioni()
  311.                     && 
  312.                     !Costanti.MODIPA_PROTOCOL_NAME.equals(this.getProtocolFactory().getProtocol())  // su ModI i certificati vengono associati per le firme
  313.                     ) {
  314.                 
  315.                 ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(datiInvocazione.getState());
  316.                 
  317.                 // NOTA: il fatto di essersi registrati come strict o come non strict è insito nella registrazione dell'applicativo
  318.                 
  319.                 ConfigurazioneFiltroServiziApplicativi filtroHttps = ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiHttps();
  320.                 
  321.                 // 1. Prima si cerca per certificato strict
  322.                 if(certificate!=null) {
  323.                     idServizioApplicativo = configurazionePdDManager.getIdServizioApplicativoByCredenzialiSsl(certificate, true,
  324.                             filtroHttps.getTipiSoggetti(), filtroHttps.isIncludiApplicativiNonModI(), filtroHttps.isIncludiApplicativiModIEsterni(), filtroHttps.isIncludiApplicativiModIInterni());
  325.                 }
  326.                 if(idServizioApplicativo==null &&
  327.                     // 2. Poi per certificato no strict
  328.                     certificate!=null) {
  329.                     idServizioApplicativo = configurazionePdDManager.getIdServizioApplicativoByCredenzialiSsl(certificate, false,
  330.                             filtroHttps.getTipiSoggetti(), filtroHttps.isIncludiApplicativiNonModI(), filtroHttps.isIncludiApplicativiModIEsterni(), filtroHttps.isIncludiApplicativiModIInterni());
  331.                 }
  332.                 if(idServizioApplicativo==null) {
  333.                     // 3. per subject/issuer
  334.                     idServizioApplicativo = configurazionePdDManager.getIdServizioApplicativoByCredenzialiSsl(subject, issuer,
  335.                             filtroHttps.getTipiSoggetti(), filtroHttps.isIncludiApplicativiNonModI(), filtroHttps.isIncludiApplicativiModIEsterni(), filtroHttps.isIncludiApplicativiModIInterni());    
  336.                 }
  337.                 if(idServizioApplicativo==null) {
  338.                     // 4. solo per subject
  339.                     idServizioApplicativo = configurazionePdDManager.getIdServizioApplicativoByCredenzialiSsl(subject, null,
  340.                             filtroHttps.getTipiSoggetti(), filtroHttps.isIncludiApplicativiNonModI(), filtroHttps.isIncludiApplicativiModIEsterni(), filtroHttps.isIncludiApplicativiModIInterni());    
  341.                 }

  343.                 if(idServizioApplicativo!=null) {
  344.                     if(idSoggetto==null) {
  345.                         idSoggetto = idServizioApplicativo.getIdSoggettoProprietario();
  346.                     }
  347.                     // Non ha senso poter identificare entrambi con le stesse credenziali
  348. //                  else if(idServizioApplicativo.getIdSoggettoProprietario().equals(idSoggetto)==false) {
  349. //                      throw new Exception("Identificato sia un soggetto che un applicativo. Il soggetto ["+idSoggetto+
  350. //                              "] identificato è differente dal proprietario dell'applicativo identificato ["+idServizioApplicativo.getIdSoggettoProprietario()+"]");
  351. //                  }
  352.                 }
  353.             }
  354.         }
  355.         catch(Exception e){
  356.             if(this.logError) {
  357.                     OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("AutenticazioneSsl (Applicativi) non riuscita",e);
  358.             }
  359.             esito.setErroreCooperazione(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, ErroriCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreCooperazione());
  360.             esito.setClientAuthenticated(false);
  361.             esito.setClientIdentified(false);
  362.             esito.setEccezioneProcessamento(e);
  363.             return esito;
  364.         }
  365.         
  366.         if(idSoggetto == null){
  367.             // L'identificazione in ssl non e' obbligatoria
  368.             /** esito.setErroreCooperazione(ErroriCooperazione.AUTENTICAZIONE_FALLITA_CREDENZIALI_FORNITE_NON_CORRETTE.getErroreCooperazione());*/
  369.             esito.setClientIdentified(false);
  370.             return esito;
  371.         }
  372.         else {
  373.             esito.setClientIdentified(true);
  374.             esito.setIdSoggetto(idSoggetto);
  375.             esito.setIdServizioApplicativo(idServizioApplicativo);
  376.         }
  377.         
  378.         return esito;
  379.         
  380.     }

  382. }
Created with JaCoCo 0.8.8.202204050719