IdentificazioneApplicativoMittenteUtils.java

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

  21. package org.openspcoop2.protocol.modipa.validator;

  23. import java.security.cert.X509Certificate;
  24. import java.util.List;
  25. import java.util.Map;

  27. import org.apache.commons.lang.StringUtils;
  28. import org.openspcoop2.core.config.Credenziali;
  29. import org.openspcoop2.core.config.ServizioApplicativo;
  30. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  31. import org.openspcoop2.core.config.constants.PortaApplicativaSoggettiFruitori;
  32. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  33. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  34. import org.openspcoop2.core.config.driver.FiltroRicercaProtocolPropertyConfig;
  35. import org.openspcoop2.core.constants.CostantiLabel;
  36. import org.openspcoop2.core.id.IDServizioApplicativo;
  37. import org.openspcoop2.core.id.IDSoggetto;
  38. import org.openspcoop2.core.registry.PortaDominio;
  39. import org.openspcoop2.core.registry.Soggetto;
  40. import org.openspcoop2.message.OpenSPCoop2Message;
  41. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  42. import org.openspcoop2.pdd.core.GestoreRichieste;
  43. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  44. import org.openspcoop2.pdd.services.core.RicezioneBusteGestioneAutenticazione;
  45. import org.openspcoop2.protocol.engine.ConfigurazioneFiltroServiziApplicativi;
  46. import org.openspcoop2.protocol.modipa.constants.ModIConsoleCostanti;
  47. import org.openspcoop2.protocol.modipa.constants.ModICostanti;
  48. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  49. import org.openspcoop2.protocol.sdk.Busta;
  50. import org.openspcoop2.protocol.sdk.Context;
  51. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  52. import org.openspcoop2.protocol.sdk.ProtocolException;
  53. import org.openspcoop2.protocol.sdk.Trasmissione;
  54. import org.openspcoop2.protocol.sdk.properties.ProtocolPropertiesUtils;
  55. import org.openspcoop2.protocol.sdk.registry.ProtocolFiltroRicercaServiziApplicativi;
  56. import org.openspcoop2.protocol.sdk.state.IState;
  57. import org.openspcoop2.protocol.sdk.state.RequestFruitore;
  58. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  59. import org.openspcoop2.protocol.utils.ModIUtils;
  60. import org.openspcoop2.security.keystore.MerlinKeystore;
  61. import org.openspcoop2.security.keystore.cache.GestoreKeystoreCache;
  62. import org.openspcoop2.utils.certificate.ArchiveLoader;
  63. import org.openspcoop2.utils.certificate.ArchiveType;
  64. import org.openspcoop2.utils.certificate.Certificate;
  65. import org.openspcoop2.utils.certificate.CertificateInfo;
  66. import org.openspcoop2.utils.certificate.CertificateUtils;
  67. import org.openspcoop2.utils.certificate.PrincipalType;
  68. import org.slf4j.Logger;

  70. /**
  71.  * IdentificazioneApplicativoMittenteUtils
  72.  *
  73.  * @author Poli Andrea (apoli@link.it)
  74.  * @author $Author$
  75.  * @version $Rev$, $Date$
  76.  */
  77. public class IdentificazioneApplicativoMittenteUtils {
  78.     
  79.     private IdentificazioneApplicativoMittenteUtils() {}

  81.     private static void logError(Logger log, String msg, Exception e) {
  82.         log.error(msg,e);
  83.     }
  84.     
  85.     // invocato in AbstractModIValidazioneSintatticaCommons e di conseguenza in ModIValidazioneSintatticaRest e ModIValidazioneSintatticaSoap durante il trattamento del token di sicurezza
  86.     public static IDServizioApplicativo identificazioneApplicativoMittenteByX509(Logger log, IState state, X509Certificate x509, OpenSPCoop2Message msg, Busta busta, 
  87.             Context context, IProtocolFactory<?> factory, RequestInfo requestInfo, MsgDiagnostico msgDiag) throws ProtocolException {
  88.         try {
  89.             
  90.             /** SICUREZZA MESSAGGIO **/
  91.                                     
  92.             IDSoggetto idSoggettoMittente = null;
  93.             if(busta.getTipoMittente()!=null && busta.getMittente()!=null) {
  94.                 idSoggettoMittente = new IDSoggetto(busta.getTipoMittente(),busta.getMittente());
  95.             }
  96.             
  97.             IDServizioApplicativo idServizioApplicativo = null;
  98.             
  99.             boolean rilevatoSoggettoIntermediario = false;
  100.             
  101.             if(x509!=null) {
  102.                 
  103.                 CertificateInfo certificate = new CertificateInfo(x509, "applicativoMittente");
  104.             
  105.                 RequestFruitore requestFruitoreToken = null;
  106.                 String certificateKey = null;
  107.                 try {
  108.                     certificateKey = GestoreRichieste.toCertificateKey(certificate);
  109.                     if(certificateKey!=null) {
  110.                         requestFruitoreToken = GestoreRichieste.readFruitoreTokenModI(requestInfo, certificateKey);
  111.                     }
  112.                 }catch(Exception t) {
  113.                     // ignore
  114.                 }   
  115.                 
  116.                 if(certificateKey!=null && requestFruitoreToken!=null && requestFruitoreToken.getCertificateKey()!=null && 
  117.                         requestFruitoreToken.getCertificateKey().equals(certificateKey)) {
  118.                     idServizioApplicativo = requestFruitoreToken.getIdServizioApplicativoFruitore();
  119.                 }
  120.                 else {
  121.                     idServizioApplicativo = identificazioneApplicativoMittenteByX509Engine(state, requestInfo, certificate);
  122.                 }
  123.                 
  124.                 if(idServizioApplicativo!=null) {
  125.                     if(idSoggettoMittente==null) {
  126.                         idSoggettoMittente = idServizioApplicativo.getIdSoggettoProprietario();
  127.                     }
  128.                     // Non ha senso poter identificare entrambi con le stesse credenziali
  129.                     else if(!idServizioApplicativo.getIdSoggettoProprietario().equals(idSoggettoMittente)) {
  130.                         Soggetto soggettoCanale = RegistroServiziManager.getInstance(state).getSoggetto(idSoggettoMittente, null, requestInfo);
  131.                         if(ModIUtils.isSoggettoCanaleIntermediario(soggettoCanale, log)) {
  132.                             String idTransazione = null;
  133.                             if(context.containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) {
  134.                                 idTransazione = (String) context.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  135.                             }
  136.                             RicezioneBusteGestioneAutenticazione.registraIntermediario(idSoggettoMittente, msgDiag, idTransazione, null, context);
  137.                             // assegno ad idSoggettoMittente il soggetto dell'applicativo
  138.                             idSoggettoMittente = idServizioApplicativo.getIdSoggettoProprietario();
  139.                             rilevatoSoggettoIntermediario = true;
  140.                         }
  141.                         else {
  142.                             String msgError = ModIUtils.getMessaggioErroreDominioCanaleDifferenteDominioApplicativo(idServizioApplicativo, idSoggettoMittente);
  143.                             throw new ProtocolException(msgError);
  144.                         }
  145.                     }
  146.                 }
  147.                 
  148.                 if(certificateKey!=null && requestFruitoreToken==null && idServizioApplicativo!=null) {
  149.                     
  150.                     ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(state);
  151.                     RegistroServiziManager registroServiziManager = RegistroServiziManager.getInstance(state);                  
  152.                     
  153.                     RequestFruitore rf = new RequestFruitore(); 
  154.                     
  155.                     rf.setIdSoggettoFruitore(idServizioApplicativo.getIdSoggettoProprietario());
  156.                     try {
  157.                         org.openspcoop2.core.registry.Soggetto soggettoRegistry = registroServiziManager.getSoggetto(idServizioApplicativo.getIdSoggettoProprietario(), null, requestInfo); 
  158.                         rf.setSoggettoFruitoreRegistry(soggettoRegistry);
  159.                     }catch(Exception t) {
  160.                         logError(log, "Errore durante la lettura del soggetto '"+idServizioApplicativo.getIdSoggettoProprietario()+"' dal registro: "+t.getMessage(),t);
  161.                     }   
  162.                     try {
  163.                         org.openspcoop2.core.config.Soggetto soggettoConfig = configurazionePdDManager.getSoggetto(idServizioApplicativo.getIdSoggettoProprietario(), requestInfo); 
  164.                         rf.setSoggettoFruitoreConfig(soggettoConfig);
  165.                     }catch(Exception t) {
  166.                         logError(log, "Errore durante la lettura del soggetto '"+idServizioApplicativo.getIdSoggettoProprietario()+"' dalla configurazione: "+t.getMessage(),t);
  167.                     }   
  168.                     try {
  169.                         String idPorta = configurazionePdDManager.getIdentificativoPorta(idServizioApplicativo.getIdSoggettoProprietario(), factory, requestInfo);
  170.                         rf.setSoggettoFruitoreIdentificativoPorta(idPorta);
  171.                     }catch(Exception t) {
  172.                         logError(log, "Errore durante la lettura dell'identificativo porta del soggetto '"+idServizioApplicativo.getIdSoggettoProprietario()+"' dal registro: "+t.getMessage(),t);
  173.                     }   
  174.                     try {
  175.                         boolean soggettoVirtualeFRU = configurazionePdDManager.isSoggettoVirtuale(idServizioApplicativo.getIdSoggettoProprietario(), requestInfo);
  176.                         rf.setSoggettoFruitoreSoggettoVirtuale(soggettoVirtualeFRU);
  177.                     }catch(Exception t) {
  178.                         logError(log, "Errore durante la lettura dell'indicazione sul soggetto virtuale associato al soggetto '"+idServizioApplicativo.getIdSoggettoProprietario()+"' dal registro: "+t.getMessage(),t);
  179.                     }   
  180.                     try {
  181.                         if(rf!=null) {
  182.                             if(rf.getSoggettoFruitoreRegistry().getPortaDominio()!=null &&
  183.                                     StringUtils.isNotEmpty(rf.getSoggettoFruitoreRegistry().getPortaDominio())) {
  184.                                 PortaDominio pdd = registroServiziManager.getPortaDominio(rf.getSoggettoFruitoreRegistry().getPortaDominio(), null, requestInfo);
  185.                                 rf.setSoggettoFruitorePddReaded(true);
  186.                                 rf.setSoggettoFruitorePdd(pdd);
  187.                             }
  188.                             else {
  189.                                 rf.setSoggettoFruitorePddReaded(true);
  190.                             }
  191.                         }
  192.                     }catch(Exception t) {
  193.                         logError(log, "Errore durante la lettura dei dati della pdd del soggetto '"+idServizioApplicativo.getIdSoggettoProprietario()+"' dal registro: "+t.getMessage(),t);
  194.                     }   
  195.                     try {
  196.                         String impl = registroServiziManager.getImplementazionePdD(idServizioApplicativo.getIdSoggettoProprietario(), null, requestInfo);
  197.                         rf.setSoggettoFruitoreImplementazionePdd(impl);
  198.                     }catch(Exception t) {
  199.                         logError(log, "Errore durante la lettura dell'implementazione pdd del soggetto '"+idServizioApplicativo.getIdSoggettoProprietario()+"' dal registro: "+t.getMessage(),t);
  200.                     }   
  201.                         
  202.                     rf.setIdServizioApplicativoFruitore(idServizioApplicativo);
  203.                     try {
  204.                         org.openspcoop2.core.config.ServizioApplicativo sa = configurazionePdDManager.getServizioApplicativo(idServizioApplicativo, requestInfo);
  205.                         rf.setServizioApplicativoFruitore(sa);
  206.                     }catch(Exception t) {
  207.                         logError(log, "Errore durante la lettura del servizio applicativo '"+idServizioApplicativo+"' dalla configurazione: "+t.getMessage(),t);
  208.                     }
  209.                     // nel token non ha senso rf.setServizioApplicativoFruitoreAnonimo(saApplicativoToken==null);
  210.                     
  211.                     try {
  212.                         rf.setCertificateKey(certificateKey);
  213.                         GestoreRichieste.saveRequestFruitoreTokenModI(requestInfo, rf);
  214.                     } catch (Exception e) {
  215.                         logError(log, "Errore durante il salvataggio nella cache e nel thread context delle informazioni sul fruitore token ModI: "+e.getMessage(),e);
  216.                     }
  217.                     
  218.                 }
  219.             }
  220.             
  221.             /** IMPOSTAZIONI */
  222.             
  223.             setInformazioniInBustaAndContext(log, state, busta, context, requestInfo,
  224.                     rilevatoSoggettoIntermediario, idSoggettoMittente, idServizioApplicativo);
  225.             
  226.             return idServizioApplicativo;
  227.             
  228.         }catch(Exception e) {
  229.             logError(log, "Errore durante il riconoscimento dell'applicativo mittente (tramite la sicurezza messaggio): "+e.getMessage(),e);
  230.             throw new ProtocolException(e.getMessage(),e);
  231.         }
  232.     }
  233.             
  234.     private static IDServizioApplicativo identificazioneApplicativoMittenteByX509Engine(IState state, RequestInfo requestInfo, CertificateInfo certificate) throws ProtocolException {
  235.             
  236.         try {
  237.         
  238.             ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(state);
  239.                                     
  240.             String subject = null;
  241.             if(certificate!=null && certificate.getCertificate()!=null) {
  242.                 subject = certificate.getCertificate().getSubjectX500Principal().toString();
  243.             }
  244.             String issuer = null;
  245.             if(certificate!=null && certificate.getCertificate()!=null && certificate.getCertificate().getIssuerX500Principal()!=null) {
  246.                 issuer = certificate.getCertificate().getIssuerX500Principal().toString();
  247.             }
  248.             
  249.             IDServizioApplicativo idServizioApplicativo = null;
  250.             
  251.             // NOTA: il fatto di essersi registrati come strict o come non strict è insito nella registrazione dell'applicativo
  252.             
  253.             // FIX: cerco solo applicativi del profilo ModI esterno
  254.             ConfigurazioneFiltroServiziApplicativi filtroFirma = ConfigurazioneFiltroServiziApplicativi.getFiltroApplicativiModIFirma();
  255.             
  256.             // 1. Prima si cerca per certificato strict
  257.             if(certificate!=null) {
  258.                 idServizioApplicativo = configurazionePdDManager.getIdServizioApplicativoByCredenzialiSsl(certificate, true, 
  259.                         filtroFirma.getTipiSoggetti(), filtroFirma.isIncludiApplicativiNonModI(), filtroFirma.isIncludiApplicativiModIEsterni(), filtroFirma.isIncludiApplicativiModIInterni());
  260.             }
  261.             if(idServizioApplicativo==null &&
  262.                 // 2. Poi per certificato no strict
  263.                 certificate!=null) {
  264.                 idServizioApplicativo = configurazionePdDManager.getIdServizioApplicativoByCredenzialiSsl(certificate, false, 
  265.                         filtroFirma.getTipiSoggetti(), filtroFirma.isIncludiApplicativiNonModI(), filtroFirma.isIncludiApplicativiModIEsterni(), filtroFirma.isIncludiApplicativiModIInterni());
  266.             }
  267.             if(idServizioApplicativo==null) {
  268.                 // 3. per subject/issuer
  269.                 idServizioApplicativo = configurazionePdDManager.getIdServizioApplicativoByCredenzialiSsl(subject, issuer, 
  270.                         filtroFirma.getTipiSoggetti(), filtroFirma.isIncludiApplicativiNonModI(), filtroFirma.isIncludiApplicativiModIEsterni(), filtroFirma.isIncludiApplicativiModIInterni());    
  271.             }
  272.             if(idServizioApplicativo==null) {
  273.                 // 4. solo per subject
  274.                 idServizioApplicativo = configurazionePdDManager.getIdServizioApplicativoByCredenzialiSsl(subject, null, 
  275.                         filtroFirma.getTipiSoggetti(), filtroFirma.isIncludiApplicativiNonModI(), filtroFirma.isIncludiApplicativiModIEsterni(), filtroFirma.isIncludiApplicativiModIInterni());    
  276.             }
  277.             if(idServizioApplicativo==null &&
  278.                 // 5. provare a vedere se si tratta di un applicativo interno (multi-tenant)
  279.                 
  280.                 StatoFunzionalita.ABILITATO.equals(configurazionePdDManager.getConfigurazioneMultitenant().getStato()) &&
  281.                         !PortaApplicativaSoggettiFruitori.SOGGETTI_ESTERNI.equals(configurazionePdDManager.getConfigurazioneMultitenant().getErogazioneSceltaSoggettiFruitori())) {
  282.                     
  283.                 ProtocolFiltroRicercaServiziApplicativi filtro = createFilter(subject, issuer);
  284.                                 
  285.                 List<IDServizioApplicativo> list = null;
  286.                 try {
  287.                     list = configurazionePdDManager.getAllIdServiziApplicativi(filtro);
  288.                 }catch(DriverConfigurazioneNotFound notFound) {
  289.                     // ignore
  290.                 }
  291.                 if(list!=null) {
  292.                     for (IDServizioApplicativo idServizioApplicativoSubjectIssuerCheck : list) {
  293.                         // Possono esistere piu' sil che hanno un CN con subject e issuer.
  294.                         
  295.                         ServizioApplicativo sa = configurazionePdDManager.getServizioApplicativo(idServizioApplicativoSubjectIssuerCheck, requestInfo);
  296.                             
  297.                         java.security.cert.Certificate certificatoCheck = readServizioApplicativoByCertificate(sa, requestInfo);

  299.                         if(
  300.                             /**if(certificate.equals(certificatoCheck.getCertificate(),true)) {*/
  301.                             certificatoCheck instanceof java.security.cert.X509Certificate &&
  302.                             certificate!=null && certificate.equals(((java.security.cert.X509Certificate)certificatoCheck),true)) {
  303.                             idServizioApplicativo = idServizioApplicativoSubjectIssuerCheck;
  304.                             break;
  305.                         }
  306.                         
  307.                     }
  308.                 }
  309.     
  310.             }
  311.                 
  312.             return idServizioApplicativo;
  313.             
  314.         }catch(Exception e) {
  315.             throw new ProtocolException(e.getMessage(),e);
  316.         }
  317.     }
  318.             
  319.             
  320.     public static IDServizioApplicativo identificazioneApplicativoMittenteByToken(Logger log, IState state, Busta busta, Context context, RequestInfo requestInfo, MsgDiagnostico msgDiag, StringBuilder errorDetails) throws ProtocolException {
  321.         try {   
  322.             
  323.             // letto tramite la sicurezza messaggio nella validazione sintattica
  324.             
  325.             IDSoggetto idSoggettoMittente = null;
  326.             if(busta.getTipoMittente()!=null && busta.getMittente()!=null) {
  327.                 idSoggettoMittente = new IDSoggetto(busta.getTipoMittente(),busta.getMittente());
  328.             }
  329.             
  330.             IDServizioApplicativo idServizioApplicativo = null;
  331.             if(busta.getServizioApplicativoFruitore()!=null && idSoggettoMittente!=null) {
  332.                 idServizioApplicativo = new IDServizioApplicativo();
  333.                 idServizioApplicativo.setNome(busta.getServizioApplicativoFruitore());
  334.                 idServizioApplicativo.setIdSoggettoProprietario(idSoggettoMittente);
  335.             }
  336.             
  337.             boolean rilevatoSoggettoIntermediario = false;
  338.             
  339.             
  340.             /** SICUREZZA TOKEN **/
  341.             
  342.             IDServizioApplicativo idServizioApplicativoToken = null;
  343.             if(context!=null && context.containsKey(org.openspcoop2.core.constants.Costanti.ID_APPLICATIVO_TOKEN)) {
  344.                 idServizioApplicativoToken = (IDServizioApplicativo) context.getObject(org.openspcoop2.core.constants.Costanti.ID_APPLICATIVO_TOKEN);
  345.                 
  346.                 if(idSoggettoMittente==null) {
  347.                     idSoggettoMittente = idServizioApplicativoToken.getIdSoggettoProprietario();
  348.                 }
  349.                 // Non ha senso poter identificare entrambi con le stesse credenziali
  350.                 else if(!idServizioApplicativoToken.getIdSoggettoProprietario().equals(idSoggettoMittente)) {
  351.                     Soggetto soggettoCanale = RegistroServiziManager.getInstance(state).getSoggetto(idSoggettoMittente, null, requestInfo);
  352.                     if(ModIUtils.isSoggettoCanaleIntermediario(soggettoCanale, log)) {
  353.                         String idTransazione = null;
  354.                         if(context.containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) {
  355.                             idTransazione = (String) context.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  356.                         }
  357.                         RicezioneBusteGestioneAutenticazione.registraIntermediario(idSoggettoMittente, msgDiag, idTransazione, null, context);
  358.                         // assegno ad idSoggettoMittente il soggetto dell'applicativo
  359.                         idSoggettoMittente = idServizioApplicativoToken.getIdSoggettoProprietario();
  360.                         rilevatoSoggettoIntermediario = true;
  361.                     }
  362.                     else {
  363.                         String msgError = ModIUtils.getMessaggioErroreDominioCanaleDifferenteDominioApplicativo(idServizioApplicativoToken, idSoggettoMittente);
  364.                         errorDetails.append(msgError);
  365.                         throw new ProtocolException(msgError);
  366.                     }       
  367.                 }
  368.                 
  369.                 if(idServizioApplicativo!=null) {
  370.                     // già identificato anche in token di sicurezza messaggio
  371.                     // DEPRECATO: non può succedere, poichè se vi è attivo una autenticazione token, viene usata quella per identificare l'applicativo mittente
  372.                     // questo caso quindi non può succedere, si lascia il codice per controllo di robustezza
  373.                     if(!idServizioApplicativo.equals(idServizioApplicativoToken)) {
  374.                         String msgError = "Rilevati due token di sicurezza firmati da applicativi differenti: '"+idServizioApplicativo.getNome()+
  375.                                 "' e '"+idServizioApplicativoToken.getNome()+"'";
  376.                         errorDetails.append(msgError);
  377.                         throw new ProtocolException(msgError);
  378.                     }
  379.                 }
  380.                 else {
  381.                     idServizioApplicativo = idServizioApplicativoToken;
  382.                 }
  383.             }
  384.             else {
  385.                 return null;
  386.             }
  387.             
  388.             
  389.             /** IMPOSTAZIONI */
  390.             
  391.             setInformazioniInBustaAndContext(log, state, busta, context, requestInfo,
  392.                     rilevatoSoggettoIntermediario, idSoggettoMittente, idServizioApplicativo);
  393.             
  394.             return idServizioApplicativo;
  395.             
  396.         }catch(Exception e) {
  397.             logError(log, "Errore durante il riconoscimento dell'applicativo mittente (tramite il token): "+e.getMessage(),e);
  398.             throw new ProtocolException(e.getMessage(),e);
  399.         }
  400.     }
  401.       
  402.     
  403.     public static void checkApplicativoTokenByX509(Logger log, IDServizioApplicativo idServizioApplicativo, 
  404.             IState state, RequestInfo requestInfo, 
  405.             String tipoToken, CertificateInfo certificatoSicurezzaMessaggio, StringBuilder errorDetails) throws ProtocolException {
  406.         try {
  407.             
  408.             ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(state);
  409.             
  410.             ServizioApplicativo saToken = configurazionePdDManager.getServizioApplicativo(idServizioApplicativo, requestInfo);
  411.             
  412.             String cnSubjectSicurezzaMessaggio = certificatoSicurezzaMessaggio.getSubject().getCN();
  413.             String subjectSicurezzaMessaggio = certificatoSicurezzaMessaggio.getSubject().toString();
  414.             String issuerSicurezzaMessaggio = null;
  415.             if(certificatoSicurezzaMessaggio.getIssuer()!=null) {
  416.                 issuerSicurezzaMessaggio = certificatoSicurezzaMessaggio.getIssuer().toString();
  417.             }
  418.             
  419.             boolean registered = false;
  420.             if(saToken.getInvocazionePorta()!=null){
  421.                 for(int z=0;z<saToken.getInvocazionePorta().sizeCredenzialiList();z++){
  422.                     
  423.                     if(saToken.getInvocazionePorta().getCredenziali(z).getTipo() == null // default
  424.                             ||
  425.                             CostantiConfigurazione.CREDENZIALE_SSL.equals(saToken.getInvocazionePorta().getCredenziali(z).getTipo())){
  426.                         
  427.                         Credenziali c = saToken.getInvocazionePorta().getCredenziali(z);
  428.                         
  429.                         // 1. Prima si cerca per certificato strict
  430.                         // 2. Poi per certificato no strict
  431.                         if(c.getCertificate()!=null &&
  432.                             cnSubjectSicurezzaMessaggio.equals(c.getCnSubject())) {
  433.                             Certificate cer = ArchiveLoader.load(ArchiveType.CER, c.getCertificate(), 0, null);
  434.                             boolean strict = true;
  435.                             if(certificatoSicurezzaMessaggio.equals(cer.getCertificate(),strict)) {
  436.                                 registered=true;
  437.                                 break;
  438.                             }
  439.                             if(certificatoSicurezzaMessaggio.equals(cer.getCertificate(),!strict)) {
  440.                                 registered=true;
  441.                                 break;
  442.                             }
  443.                         }
  444.                         
  445.                         // 3. per subject/issuer
  446.                         // 4. solo per subject
  447.                         if(c.getSubject()!=null) {
  448.                         
  449.                             boolean subjectValid = CertificateUtils.sslVerify(c.getSubject(), subjectSicurezzaMessaggio, PrincipalType.SUBJECT, log);
  450.                             boolean issuerValid = true;
  451.                             if(subjectValid &&
  452.                                 c.getIssuer()!=null &&
  453.                                 issuerSicurezzaMessaggio!=null) {
  454.                                 issuerValid = CertificateUtils.sslVerify(c.getIssuer(), issuerSicurezzaMessaggio, PrincipalType.ISSUER, log);
  455.                             }
  456.                             
  457.                             if(subjectValid && issuerValid){
  458.                                 registered=true;
  459.                                 break;
  460.                             }
  461.                         }
  462.                                                 
  463.                     }
  464.                     
  465.                 }
  466.             }
  467.             
  468.             // 5. provare a vedere se si tratta di un applicativo interno (multi-tenant)
  469.             
  470.             if(!registered &&
  471.                 StatoFunzionalita.ABILITATO.equals(configurazionePdDManager.getConfigurazioneMultitenant().getStato()) &&
  472.                 !PortaApplicativaSoggettiFruitori.SOGGETTI_ESTERNI.equals(configurazionePdDManager.getConfigurazioneMultitenant().getErogazioneSceltaSoggettiFruitori())) {
  473.                         
  474.                 java.security.cert.Certificate certificatoCheck = readServizioApplicativoByCertificate(saToken, requestInfo);

  476.                 if(
  477.                     /**if(certificate.equals(certificatoCheck.getCertificate(),true)) {*/
  478.                     certificatoCheck instanceof java.security.cert.X509Certificate &&
  479.                     certificatoSicurezzaMessaggio.equals(((java.security.cert.X509Certificate)certificatoCheck),true)) {
  480.                     registered=true;
  481.                 }
  482.             }
  483.             
  484.             if(!registered) {
  485.                 
  486.                 StringBuilder sb = new StringBuilder();
  487.                 sb.append("subject=\"").append(subjectSicurezzaMessaggio).append("\"");
  488.                 if(issuerSicurezzaMessaggio!=null) {
  489.                     sb.append(" issuer=\"").append(issuerSicurezzaMessaggio).append("\"");
  490.                 }
  491.                 
  492.                 String idApp = idServizioApplicativo.getNome() + " (Soggetto: "+idServizioApplicativo.getIdSoggettoProprietario().getNome()+")";
  493.                 String msgError = "Applicativo Mittente "+idApp+" non autorizzato; il certificato di firma ("+sb.toString()+") del security token ("+tipoToken+") non corrisponde all'applicativo";
  494.                 errorDetails.append(msgError);
  495.                 throw new ProtocolException(msgError);
  496.             }
  497.             
  498.         }catch(Exception e) {
  499.             logError(log, "Errore durante la verifica del certificato di firma associato all'applicativo token: "+e.getMessage(),e);
  500.             throw new ProtocolException(e.getMessage(),e);
  501.         }
  502.     }
  503.     
  504.     
  505.     
  506.     public static void setInformazioniInBustaAndContext(Logger log, IState state, Busta busta, Context context, RequestInfo requestInfo,
  507.             boolean rilevatoSoggettoIntermediario, IDSoggetto idSoggettoMittente, IDServizioApplicativo idServizioApplicativo) throws ProtocolException {
  508.         try {
  509.                         
  510.             if(idSoggettoMittente!=null) {
  511.                 busta.setTipoMittente(idSoggettoMittente.getTipo());
  512.                 busta.setMittente(idSoggettoMittente.getNome());
  513.                 
  514.                 if(rilevatoSoggettoIntermediario) {
  515.                     // devo aggiornare anche altri campi della busta
  516.                     try {
  517.                         RegistroServiziManager registroServiziManager = RegistroServiziManager.getInstance(state);
  518.                         Soggetto soggetto = registroServiziManager.getSoggetto(idSoggettoMittente, null, requestInfo);
  519.                         busta.setIdentificativoPortaMittente(soggetto.getIdentificativoPorta());
  520.                         if(busta.sizeListaTrasmissioni()==1) {
  521.                             Trasmissione tr = busta.getTrasmissione(0);
  522.                             tr.setTipoOrigine(idSoggettoMittente.getTipo());
  523.                             tr.setOrigine(idSoggettoMittente.getNome());
  524.                             tr.setIdentificativoPortaOrigine(soggetto.getIdentificativoPorta());
  525.                         }
  526.                     }catch(Exception t) {
  527.                         // ignore
  528.                     }
  529.                 }
  530.                 
  531.                 try {
  532.                     if(!context.containsKey(org.openspcoop2.core.constants.Costanti.PROPRIETA_SOGGETTO_FRUITORE)) {
  533.                         RegistroServiziManager registroServiziManager = RegistroServiziManager.getInstance(state);
  534.                         Soggetto soggetto = registroServiziManager.getSoggetto(idSoggettoMittente, null, requestInfo);
  535.                         Map<String, String> configProperties = registroServiziManager.getProprietaConfigurazione(soggetto);
  536.                         if (configProperties != null && !configProperties.isEmpty()) {
  537.                             context.addObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_SOGGETTO_FRUITORE, configProperties);
  538.                         }   
  539.                     }
  540.                 }catch(Exception t) {
  541.                     // ignore
  542.                 }
  543.             }
  544.             
  545.         }catch(Exception e) {
  546.             logError(log, "Errore durante l'impostazione nel contest del soggetto mittente: "+e.getMessage(),e);
  547.             throw new ProtocolException(e.getMessage(),e);
  548.         }
  549.         
  550.         try {
  551.             
  552.             if(idServizioApplicativo!=null) {
  553.                 busta.setServizioApplicativoFruitore(idServizioApplicativo.getNome());
  554.                 
  555.                 try {
  556.                     if(!context.containsKey(org.openspcoop2.core.constants.Costanti.PROPRIETA_APPLICATIVO)) {
  557.                         ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(state);
  558.                         ServizioApplicativo sa = configurazionePdDManager.getServizioApplicativo(idServizioApplicativo, requestInfo);
  559.                         Map<String, String> configProperties = configurazionePdDManager.getProprietaConfigurazione(sa);
  560.                         if (configProperties != null && !configProperties.isEmpty()) {
  561.                             context.addObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_APPLICATIVO, configProperties);
  562.                         }   
  563.                     }
  564.                 }catch(Exception t) {
  565.                     // ignore
  566.                 }
  567.             }
  568.             
  569.         }catch(Exception e) {
  570.             logError(log, "Errore durante l'impostazione nel contest dell'applicativo mittente: "+e.getMessage(),e);
  571.             throw new ProtocolException(e.getMessage(),e);
  572.         }
  573.     }
  574.     
  575.     
  576.     
  577.     
  578.     public static ProtocolFiltroRicercaServiziApplicativi createFilter(String subject, String issuer) {
  579.         ProtocolFiltroRicercaServiziApplicativi filtro = new ProtocolFiltroRicercaServiziApplicativi();
  580.         
  581.         filtro.setTipoSoggetto(CostantiLabel.MODIPA_PROTOCOL_NAME);
  582.         
  583.         FiltroRicercaProtocolPropertyConfig filtroSubject = new FiltroRicercaProtocolPropertyConfig();
  584.         filtroSubject.setName(ModICostanti.MODIPA_KEY_CN_SUBJECT);
  585.         filtroSubject.setValueAsString(subject);
  586.         filtro.addProtocolProperty(filtroSubject);
  587.         
  588.         FiltroRicercaProtocolPropertyConfig filtroIssuer = new FiltroRicercaProtocolPropertyConfig();
  589.         filtroIssuer.setName(ModICostanti.MODIPA_KEY_CN_ISSUER);
  590.         filtroIssuer.setValueAsString(issuer);
  591.         filtro.addProtocolProperty(filtroIssuer);
  592.         
  593.         return filtro;
  594.     }
  595.     
  596.     public static java.security.cert.Certificate readServizioApplicativoByCertificate(ServizioApplicativo sa, RequestInfo requestInfo) throws ProtocolException {
  597.         if(sa!=null && sa.sizeProtocolPropertyList()>0) {
  598.                     
  599.             java.security.cert.Certificate certificatoCheck = null;
  600.                     
  601.             String mode = ProtocolPropertiesUtils.getOptionalStringValuePropertyConfig(sa.getProtocolPropertyList(), ModICostanti.MODIPA_KEYSTORE_MODE);
  602.             if(mode!=null && !"".equals(mode) && !ModICostanti.MODIPA_KEYSTORE_MODE_VALUE_ARCHIVE.equals(mode)) {
  603.                         
  604.                 byte [] certificateBytes = ProtocolPropertiesUtils.getOptionalBinaryValuePropertyConfig(sa.getProtocolPropertyList(), ModICostanti.MODIPA_KEYSTORE_CERTIFICATE);
  605.                 if(certificateBytes!=null) {
  606.                     org.openspcoop2.utils.certificate.Certificate c = null;
  607.                     try {
  608.                         c = ArchiveLoader.load(certificateBytes);
  609.                     }catch(Exception e) {
  610.                         throw new ProtocolException(e.getMessage(),e);
  611.                     }
  612.                     if(c!=null && c.getCertificate()!=null) {
  613.                         certificatoCheck = c.getCertificate().getCertificate();
  614.                     }
  615.                 }
  616.                 
  617.             }
  618.             else {
  619.                 
  620.                 byte [] keystoreBytes = ProtocolPropertiesUtils.getOptionalBinaryValuePropertyConfig(sa.getProtocolPropertyList(), ModICostanti.MODIPA_KEYSTORE_ARCHIVE);
  621.                 String keystoreType = ProtocolPropertiesUtils.getOptionalStringValuePropertyConfig(sa.getProtocolPropertyList(), ModICostanti.MODIPA_KEYSTORE_TYPE);
  622.                 String keystorePassword = ProtocolPropertiesUtils.getOptionalStringValuePropertyConfig(sa.getProtocolPropertyList(), ModICostanti.MODIPA_KEYSTORE_PASSWORD);
  623.                 String keyAlias = ProtocolPropertiesUtils.getOptionalStringValuePropertyConfig(sa.getProtocolPropertyList(), ModICostanti.MODIPA_KEY_ALIAS);
  624.                 if(keystoreBytes!=null && keystoreType!=null && keystorePassword!=null && keyAlias!=null) {
  625.                     ArchiveType archiveType = null;
  626.                     if(ModIConsoleCostanti.MODIPA_KEYSTORE_TYPE_VALUE_JKS.equals(keystoreType)) {
  627.                         archiveType = ArchiveType.JKS;
  628.                     }
  629.                     else {
  630.                         archiveType = ArchiveType.PKCS12;
  631.                     }
  632.                     try {
  633.                         MerlinKeystore merlinKs = GestoreKeystoreCache.getMerlinKeystore(requestInfo, keystoreBytes, archiveType.name(), 
  634.                                 keystorePassword);
  635.                         certificatoCheck = merlinKs.getCertificate(keyAlias);
  636.                     }catch(Exception e) {
  637.                         throw new ProtocolException(e.getMessage(),e);
  638.                     }
  639.                 }
  640.             }

  642.             return certificatoCheck;
  643.         }
  644.             
  645.         return null;
  646.     }
  647. }
Created with JaCoCo 0.8.8.202204050719