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.pd;

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

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

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

  62. public class AutenticazioneSsl extends AbstractAutenticazioneBase {

  64.     private boolean logError = true;
  65.     @Override
  66.     public void setLogError(boolean logError) {
  67.         this.logError = logError;
  68.     }
  69.     
  70.     @Override
  71.     public EsitoAutenticazionePortaDelegata process(DatiInvocazionePortaDelegata datiInvocazione) throws AutenticazioneException{

  73.         EsitoAutenticazionePortaDelegata esito = new EsitoAutenticazionePortaDelegata();
  74.         
  75.         OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  76.         WWWAuthenticateConfig wwwAuthenticateConfig = op2Properties.getRealmAutenticazioneHttpsWWWAuthenticateConfig();
  77.         
  78.         if(datiInvocazione==null) {
  79.             throw new AutenticazioneException("Param datiInvocazione is null");
  80.         }
  81.         
  82.         IDSoggetto soggettoFruitore = null;
  83.         if(datiInvocazione.getPd()!=null) {
  84.             soggettoFruitore = new IDSoggetto(datiInvocazione.getPd().getTipoSoggettoProprietario(), datiInvocazione.getPd().getNomeSoggettoProprietario());
  85.         }
  86.                 
  87.         Credenziali credenziali = datiInvocazione.getInfoConnettoreIngresso().getCredenziali();
  88.         
  89.         String subject = credenziali.getSubject();
  90.         String issuer = credenziali.getIssuer();
  91.         CertificateInfo certificate = null;
  92.         if(credenziali.getCertificate()!=null) {
  93.             certificate = credenziali.getCertificate().getCertificate();
  94.         }
  95.         
  96.         RequestInfo requestInfo = datiInvocazione.getRequestInfo();
  97.         
  98.         // Controllo credenziali fornite
  99.         if( subject==null || "".equals(subject) ){
  100.             esito.setErroreIntegrazione(IntegrationFunctionError.AUTHENTICATION_CREDENTIALS_NOT_FOUND, ErroriIntegrazione.ERRORE_402_AUTENTICAZIONE_FALLITA.getErrore402_AutenticazioneFallitaSsl(CostantiProtocollo.CREDENZIALI_NON_FORNITE,subject));
  101.             esito.setClientAuthenticated(false);
  102.             esito.setClientIdentified(false);
  103.             if(wwwAuthenticateConfig!=null) {
  104.                 esito.setWwwAuthenticateErrorHeader(wwwAuthenticateConfig.buildWWWAuthenticateHeaderValue_notFound());
  105.             }
  106.             return esito;
  107.         }
  108.         if(credenziali.getCertificate()!=null) {
  109.             certificate = credenziali.getCertificate().getCertificate();
  110.             
  111.             List<Proprieta> proprieta = null;
  112.             if(datiInvocazione.getPd()!=null) {
  113.                 proprieta = datiInvocazione.getPd().getProprietaList();
  114.             }

  116.             boolean checkValid = false;
  117.             boolean trustStore = false;
  118.             KeyStore trustStoreCertificatiX509 = null;
  119.             CertStore trustStoreCertificatiX509crls = null;
  120.             IOCSPValidator ocspValidator = null;
  121.             try {
  122.                 checkValid = CostantiProprieta.isAutenticazioneHttpsValidityCheck(proprieta, op2Properties.isAutenticazioneHttpsPortaDelegataValidityCheck());
  123.                 trustStore = CostantiProprieta.isAutenticazioneHttpsTrustStore(proprieta, op2Properties.getAutenticazioneHttpsPortaDelegataTruststorePath());
  124.                 if(trustStore) {
  125.                     String path = CostantiProprieta.getAutenticazioneHttpsTrustStorePath(proprieta, op2Properties.getAutenticazioneHttpsPortaDelegataTruststorePath());
  126.                     if(path!=null) {
  127.                         try {
  128.                             String password = CostantiProprieta.getAutenticazioneHttpsTrustStorePassword(proprieta, op2Properties.getAutenticazioneHttpsPortaDelegataTruststorePassword());
  129.                             String type = CostantiProprieta.getAutenticazioneHttpsTrustStoreType(proprieta, op2Properties.getAutenticazioneHttpsPortaDelegataTruststoreType());
  130.                             trustStoreCertificatiX509 = GestoreKeystoreCaching.getMerlinTruststore(requestInfo, path, 
  131.                                     type, 
  132.                                     password).getTrustStore();
  133.                         }catch(Exception e){
  134.                             throw new CoreException("Errore durante la lettura del truststore indicato ("+path+"): "+e.getMessage());
  135.                         }
  136.                     }
  137.                     
  138.                     if(trustStoreCertificatiX509!=null) {
  139.                         String crl = CostantiProprieta.getAutenticazioneHttpsTrustStoreCRLs(proprieta, op2Properties.getAutenticazioneHttpsPortaDelegataTruststoreCRLs());
  140.                         
  141.                         boolean crlByOcsp = false;
  142.                         String ocspPolicy = CostantiProprieta.getAutenticazioneHttpsTrustStoreOCSPPolicy(proprieta, op2Properties.getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy());
  143.                         if(ocspPolicy!=null) {
  144.                             LoggerBuffer lb = new LoggerBuffer();
  145.                             lb.setLogDebug(OpenSPCoop2Logger.getLoggerOpenSPCoopCore());
  146.                             lb.setLogError(OpenSPCoop2Logger.getLoggerOpenSPCoopCore());
  147.                             GestoreOCSPResource ocspResourceReader = new GestoreOCSPResource(requestInfo);
  148.                             try {
  149.                                 ocspValidator = new GestoreOCSPValidator(requestInfo, lb, 
  150.                                         trustStoreCertificatiX509,
  151.                                         crl, 
  152.                                         ocspPolicy, 
  153.                                         ocspResourceReader);
  154.                             }catch(Exception e){
  155.                                 throw new CoreException("Errore durante l'inizializzazione del gestore della policy OCSP ("+ocspPolicy+"): "+e.getMessage());
  156.                             }
  157.                             if(ocspValidator!=null) {
  158.                                 GestoreOCSPValidator gOcspValidator = (GestoreOCSPValidator) ocspValidator;
  159.                                 if(gOcspValidator.getOcspConfig()!=null) {
  160.                                     crlByOcsp = gOcspValidator.getOcspConfig().isCrl();
  161.                                 }
  162.                             }
  163.                         }
  164.                         
  165.                         if(crl!=null && !crlByOcsp) {
  166.                             try {
  167.                                 trustStoreCertificatiX509crls = GestoreKeystoreCaching.getCRLCertstore(requestInfo, crl).getCertStore();
  168.                             }catch(Exception e){
  169.                                 throw new CoreException("Errore durante la lettura delle CRLs ("+crl+"): "+e.getMessage());
  170.                             }
  171.                         }
  172.                     }
  173.                 }
  174.             }catch(Exception e) {
  175.                 if(this.logError) {
  176.                     OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("AutenticazioneSsl non riuscita",e);
  177.                 }
  178.                 esito.setErroreIntegrazione(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  179.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE));
  180.                 esito.setClientIdentified(false);
  181.                 esito.setEccezioneProcessamento(e);
  182.                 return esito;
  183.             }
  184.             
  185.             if(checkValid 
  186.                     &&
  187.                     trustStoreCertificatiX509crls==null) { // altrimenti la validita' viene verificata insieme alle CRL
  188.                 try {
  189.                     certificate.checkValid();
  190.                 }catch(Exception e) {
  191.                     esito.setErroreIntegrazione(IntegrationFunctionError.AUTHENTICATION_INVALID_CREDENTIALS, 
  192.                             ErroriIntegrazione.ERRORE_402_AUTENTICAZIONE_FALLITA.getErrore402_AutenticazioneFallitaSsl(CostantiProtocollo.CREDENZIALI_FORNITE_NON_CORRETTE+": "+e.getMessage(),subject));
  193.                     esito.setClientAuthenticated(false);
  194.                     esito.setClientIdentified(false);
  195.                     if(wwwAuthenticateConfig!=null) {
  196.                         esito.setWwwAuthenticateErrorHeader(wwwAuthenticateConfig.buildWWWAuthenticateHeaderValue_invalid());
  197.                     }
  198.                     return esito;
  199.                 }
  200.             }
  201.             
  202.             if(trustStoreCertificatiX509!=null) {
  203.                 try {
  204.                     if(!certificate.isVerified(trustStoreCertificatiX509, true)) {
  205.                         throw new CoreException("Certificato non verificabile rispetto alle CA conosciute");
  206.                     }
  207.                     if(trustStoreCertificatiX509crls!=null) {
  208.                         try {
  209.                             certificate.checkValid(trustStoreCertificatiX509crls, trustStoreCertificatiX509);
  210.                         }catch(Throwable t) {
  211.                             throw new CoreException("Certificato non valido: "+t.getMessage());
  212.                         }
  213.                     }
  214.                 }catch(Exception e) {
  215.                     esito.setErroreIntegrazione(IntegrationFunctionError.AUTHENTICATION_INVALID_CREDENTIALS, 
  216.                             ErroriIntegrazione.ERRORE_402_AUTENTICAZIONE_FALLITA.getErrore402_AutenticazioneFallitaSsl(CostantiProtocollo.CREDENZIALI_FORNITE_NON_CORRETTE+": "+e.getMessage(),subject));
  217.                     esito.setClientAuthenticated(false);
  218.                     esito.setClientIdentified(false);
  219.                     if(wwwAuthenticateConfig!=null) {
  220.                         esito.setWwwAuthenticateErrorHeader(wwwAuthenticateConfig.buildWWWAuthenticateHeaderValue_invalid());
  221.                     }
  222.                     return esito;
  223.                 }
  224.             }
  225.             
  226.             if(ocspValidator!=null) {
  227.                 try {
  228.                     ocspValidator.valid(certificate.getCertificate());
  229.                 }catch(Throwable t) {
  230.                     esito.setErroreIntegrazione(IntegrationFunctionError.AUTHENTICATION_INVALID_CREDENTIALS, 
  231.                             ErroriIntegrazione.ERRORE_402_AUTENTICAZIONE_FALLITA.getErrore402_AutenticazioneFallitaSsl(CostantiProtocollo.CREDENZIALI_FORNITE_NON_CORRETTE+": "+t.getMessage(),subject));
  232.                     esito.setClientAuthenticated(false);
  233.                     esito.setClientIdentified(false);
  234.                     if(!(t instanceof OCSPResponseException)) {
  235.                         esito.setNoCache(true);
  236.                     }
  237.                     if(wwwAuthenticateConfig!=null) {
  238.                         esito.setWwwAuthenticateErrorHeader(wwwAuthenticateConfig.buildWWWAuthenticateHeaderValue_invalid());
  239.                     }
  240.                     return esito;
  241.                 }
  242.             }

  244.         }
  245.         
  246.         // Essendoci l'identita' del chiamante, il client e' stato autenticato o da un frontend o dall'application server stesso
  247.         esito.setClientAuthenticated(true);
  248.         esito.setCredential(subject);
  249.         
  250.         // Provo a identificare il chiamante rispetto ad una entita' del registro
  251.         IDServizioApplicativo idServizioApplicativo = null;
  252.         try{
  253.             ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(datiInvocazione.getState());
  254.             
  255.             // NOTA: il fatto di essersi registrati come strict o come non strict รจ insito nella registrazione dell'applicativo
  256.             
  257.             ConfigurazioneFiltroServiziApplicativi filtroHttps = ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiHttps();
  258.             
  259.             // 1. Prima si cerca per certificato strict
  260.             if(certificate!=null) {
  261.                 idServizioApplicativo = configurazionePdDManager.getIdServizioApplicativoByCredenzialiSsl(certificate, true,
  262.                         filtroHttps.getTipiSoggetti(), filtroHttps.isIncludiApplicativiNonModI(), filtroHttps.isIncludiApplicativiModIEsterni(), filtroHttps.isIncludiApplicativiModIInterni());
  263.             }
  264.             if(idServizioApplicativo==null &&
  265.                 // 2. Poi per certificato no strict
  266.                 certificate!=null) {
  267.                 idServizioApplicativo = configurazionePdDManager.getIdServizioApplicativoByCredenzialiSsl(certificate, false,
  268.                         filtroHttps.getTipiSoggetti(), filtroHttps.isIncludiApplicativiNonModI(), filtroHttps.isIncludiApplicativiModIEsterni(), filtroHttps.isIncludiApplicativiModIInterni());
  269.             }
  270.             if(idServizioApplicativo==null) {
  271.                 // 3. per subject/issuer
  272.                 idServizioApplicativo = configurazionePdDManager.getIdServizioApplicativoByCredenzialiSsl(subject, issuer,
  273.                         filtroHttps.getTipiSoggetti(), filtroHttps.isIncludiApplicativiNonModI(), filtroHttps.isIncludiApplicativiModIEsterni(), filtroHttps.isIncludiApplicativiModIInterni());    
  274.             }
  275.             if(idServizioApplicativo==null) {
  276.                 // 4. solo per subject
  277.                 idServizioApplicativo = configurazionePdDManager.getIdServizioApplicativoByCredenzialiSsl(subject, null,
  278.                         filtroHttps.getTipiSoggetti(), filtroHttps.isIncludiApplicativiNonModI(), filtroHttps.isIncludiApplicativiModIEsterni(), filtroHttps.isIncludiApplicativiModIInterni());    
  279.             }
  280.             
  281.             if(idServizioApplicativo!=null && soggettoFruitore==null) {
  282.                 soggettoFruitore = idServizioApplicativo.getIdSoggettoProprietario();
  283.             }
  284.         }catch(Exception e){
  285.             if(this.logError) {
  286.                 OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("AutenticazioneSsl non riuscita",e);
  287.             }
  288.             esito.setErroreIntegrazione(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  289.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE));
  290.             esito.setClientIdentified(false);
  291.             esito.setEccezioneProcessamento(e);
  292.             return esito;
  293.         }
  294.         
  295.         if(idServizioApplicativo == null){
  296.             // L'identificazione in ssl non e' obbligatoria
  297.             /**esito.setErroreIntegrazione(ErroriIntegrazione.ERRORE_402_AUTENTICAZIONE_FALLITA.getErrore402_AutenticazioneFallitaSsl(CostantiProtocollo.CREDENZIALI_FORNITE_NON_CORRETTE,subject));*/
  298.             esito.setClientIdentified(false);
  299.         }
  300.         else {
  301.             if(OpenSPCoop2Properties.getInstance().isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari() && !idServizioApplicativo.getIdSoggettoProprietario().equals(soggettoFruitore)) {
  302.                 esito.setErroreIntegrazione(IntegrationFunctionError.AUTHENTICATION_INVALID_CREDENTIALS, 
  303.                         ErroriIntegrazione.ERRORE_402_AUTENTICAZIONE_FALLITA.getErrore402_AutenticazioneFallitaSsl(
  304.                                 "soggetto proprietario ("+idServizioApplicativo.getIdSoggettoProprietario()+") dell'applicativo identificato ("+idServizioApplicativo.getNome()+") differente dal soggetto proprietario della porta invocata ("+soggettoFruitore+")",subject));
  305.                 esito.setClientIdentified(false);
  306.                 return esito;
  307.             }
  308.             else {
  309.                 esito.setClientIdentified(true);
  310.                 esito.setIdServizioApplicativo(idServizioApplicativo);
  311.             }
  312.         }
  313.         
  314.         return esito;
  315.         
  316.     }

  318. }
Created with JaCoCo 0.8.8.202204050719