ModIValidazioneSintattica.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.protocol.modipa.validator;


  26. import java.util.ArrayList;
  27. import java.util.HashMap;
  28. import java.util.List;
  29. import java.util.Map;

  31. import javax.xml.soap.SOAPEnvelope;

  33. import org.apache.commons.lang.StringUtils;
  34. import org.openspcoop2.core.config.ServizioApplicativo;
  35. import org.openspcoop2.core.constants.Costanti;
  36. import org.openspcoop2.core.constants.TipoPdD;
  37. import org.openspcoop2.core.id.IDAccordo;
  38. import org.openspcoop2.core.id.IDServizio;
  39. import org.openspcoop2.core.id.IDServizioApplicativo;
  40. import org.openspcoop2.core.id.IDSoggetto;
  41. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  42. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  43. import org.openspcoop2.core.registry.ProtocolProperty;
  44. import org.openspcoop2.core.registry.Resource;
  45. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  46. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  47. import org.openspcoop2.message.OpenSPCoop2Message;
  48. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  49. import org.openspcoop2.pdd.core.CostantiPdD;
  50. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  51. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  52. import org.openspcoop2.protocol.basic.validator.ValidazioneSintattica;
  53. import org.openspcoop2.protocol.engine.utils.NamingUtils;
  54. import org.openspcoop2.protocol.modipa.AbstractModISecurityToken;
  55. import org.openspcoop2.protocol.modipa.ModIBustaRawContent;
  56. import org.openspcoop2.protocol.modipa.config.ModIProperties;
  57. import org.openspcoop2.protocol.modipa.constants.ModICostanti;
  58. import org.openspcoop2.protocol.modipa.constants.ModIHeaderType;
  59. import org.openspcoop2.protocol.modipa.utils.ModIPropertiesUtils;
  60. import org.openspcoop2.protocol.modipa.utils.ModISecurityConfig;
  61. import org.openspcoop2.protocol.modipa.utils.ModITruststoreConfig;
  62. import org.openspcoop2.protocol.modipa.utils.ModIUtilities;
  63. import org.openspcoop2.protocol.sdk.Busta;
  64. import org.openspcoop2.protocol.sdk.Eccezione;
  65. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  66. import org.openspcoop2.protocol.sdk.ProtocolException;
  67. import org.openspcoop2.protocol.sdk.SecurityToken;
  68. import org.openspcoop2.protocol.sdk.constants.CodiceErroreCooperazione;
  69. import org.openspcoop2.protocol.sdk.constants.ErroreCooperazione;
  70. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  71. import org.openspcoop2.protocol.sdk.properties.ProtocolPropertiesUtils;
  72. import org.openspcoop2.protocol.sdk.registry.IConfigIntegrationReader;
  73. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  74. import org.openspcoop2.protocol.sdk.state.IState;
  75. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  76. import org.openspcoop2.protocol.sdk.validator.ProprietaValidazioneErrori;
  77. import org.openspcoop2.protocol.sdk.validator.ValidazioneSintatticaResult;
  78. import org.openspcoop2.protocol.sdk.validator.ValidazioneUtils;
  79. import org.openspcoop2.utils.transport.http.HttpConstants;

  81. /**
  82.  * Classe che implementa, in base al protocollo ModI, l'interfaccia {@link org.openspcoop2.protocol.sdk.validator.IValidazioneSintattica}
  83.  *
  84.  * @author Poli Andrea (apoli@link.it)
  85.  * @author Lorenzo Nardi (nardi@link.it)
  86.  * @author $Author$
  87.  * @version $Rev$, $Date$
  88.  */
  89. public class ModIValidazioneSintattica extends ValidazioneSintattica<AbstractModISecurityToken<?>>{

  91.     /** ValidazioneUtils */
  92.     protected ValidazioneUtils validazioneUtils;
  93.     private ModIProperties modiProperties;
  94.     
  95.     public ModIValidazioneSintattica(IProtocolFactory<AbstractModISecurityToken<?>> factory, IState state) throws ProtocolException {
  96.         super(factory, state);
  97.         this.validazioneUtils = new ValidazioneUtils(factory);
  98.         this.modiProperties = ModIProperties.getInstance();
  99.     }
  100.     
  101.     private static final String DIAGNOSTIC_VALIDATE_TOKEN_ID_AUTH = "validateTokenIdAuth";
  102.     private static final String DIAGNOSTIC_VALIDATE_TOKEN_INTEGRITY = "validateTokenIntegrity";
  103.     private static final String DIAGNOSTIC_IN_CORSO = "inCorso";
  104.     private static final String DIAGNOSTIC_COMPLETATA = "completata";
  105.     private static final String DIAGNOSTIC_FALLITA = "fallita";

  107.     
  108.     @Override
  109.     public ValidazioneSintatticaResult<AbstractModISecurityToken<?>> validaRichiesta(OpenSPCoop2Message msg,
  110.             Busta datiBustaLettiURLMappingProperties, ProprietaValidazioneErrori proprietaValidazioneErrori)
  111.             throws ProtocolException {
  112.         
  113.         ValidazioneSintatticaResult<AbstractModISecurityToken<?>> basicResult = super.validaRichiesta(msg, datiBustaLettiURLMappingProperties, proprietaValidazioneErrori);
  114.         return this.validate(basicResult, true, msg, datiBustaLettiURLMappingProperties);

  116.     }
  117.     
  118.     @Override
  119.     public ValidazioneSintatticaResult<AbstractModISecurityToken<?>> validaRisposta(OpenSPCoop2Message msg,
  120.             Busta bustaRichiesta, ProprietaValidazioneErrori proprietaValidazioneErrori) throws ProtocolException {
  121.         
  122.         ValidazioneSintatticaResult<AbstractModISecurityToken<?>> basicResult = super.validaRisposta(msg, bustaRichiesta, proprietaValidazioneErrori);
  123.         return this.validate(basicResult, false, msg, bustaRichiesta);
  124.         
  125.     }
  126.     
  127.     private ValidazioneSintatticaResult<AbstractModISecurityToken<?>> validate(ValidazioneSintatticaResult<AbstractModISecurityToken<?>> basicResult, 
  128.             boolean request, OpenSPCoop2Message msg, Busta datiRichiesta) {
  129.         List<Eccezione> erroriValidazione = new ArrayList<>();
  130.         List<Eccezione> erroriProcessamento = new ArrayList<>();
  131.         
  132.         ModIBustaRawContent rawContent = null;
  133.         
  134.         Busta bustaRitornata = basicResult.getBusta();
  135.         
  136.         String erroreProcessamentoInternalMessage = null;
  137.         try {
  138.                     
  139.             IDServizio idServizio = null;
  140.             if(datiRichiesta!=null && 
  141.                     datiRichiesta.getTipoDestinatario()!=null && datiRichiesta.getDestinatario()!=null &&
  142.                     datiRichiesta.getTipoServizio()!=null && datiRichiesta.getServizio()!=null &&
  143.                     datiRichiesta.getVersioneServizio()!=null) {
  144.                 idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(datiRichiesta.getTipoServizio(), datiRichiesta.getServizio(), 
  145.                         datiRichiesta.getTipoDestinatario(), datiRichiesta.getDestinatario(), 
  146.                         datiRichiesta.getVersioneServizio());
  147.                 
  148.                 RequestInfo requestInfo = null;
  149.                 if(this.context!=null && this.context.containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  150.                     requestInfo = (RequestInfo) this.context.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  151.                 }
  152.                 
  153.                 IRegistryReader registryReader = this.getProtocolFactory().getCachedRegistryReader(this.state, requestInfo);
  154.                 IConfigIntegrationReader configIntegrationReader = this.getProtocolFactory().getCachedConfigIntegrationReader(this.state, requestInfo);
  155.                 
  156.                 AccordoServizioParteSpecifica asps = registryReader.getAccordoServizioParteSpecifica(idServizio);
  157.                 
  158.                 IDAccordo idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromUri(asps.getAccordoServizioParteComune());
  159.                 AccordoServizioParteComune aspc = registryReader.getAccordoServizioParteComune(idAccordo);
  160.                 boolean rest = org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(aspc.getServiceBinding());
  161.                 
  162.                 String nomePortType = asps.getPortType();
  163.                 String azione = datiRichiesta.getAzione();
  164.                 
  165.                 IDSoggetto idSoggettoMittente = null;
  166.                 if(!request &&  datiRichiesta.getTipoMittente()!=null &&
  167.                         datiRichiesta.getMittente()!=null) {
  168.                     
  169.                     idSoggettoMittente = new IDSoggetto(datiRichiesta.getTipoMittente(),datiRichiesta.getMittente());
  170.                     
  171.                 }
  172.                 
  173.                 IDServizioApplicativo idSA = null;
  174.                 ServizioApplicativo sa = null;
  175.                 if(!request && datiRichiesta.getServizioApplicativoFruitore()!=null &&
  176.                         !CostantiPdD.SERVIZIO_APPLICATIVO_ANONIMO.equals(datiRichiesta.getServizioApplicativoFruitore()) &&
  177.                         idSoggettoMittente!=null) {
  178.                     
  179.                     idSA = new IDServizioApplicativo();
  180.                     idSA.setIdSoggettoProprietario(idSoggettoMittente);
  181.                     idSA.setNome(datiRichiesta.getServizioApplicativoFruitore());
  182.                     
  183.                     sa = configIntegrationReader.getServizioApplicativo(idSA);
  184.                 }
  185.                 if(!request && sa==null) {
  186.                     // provo a vedere se autenticato tramite autenticazione token
  187.                     IDServizioApplicativo idServizioApplicativoToken = null;
  188.                     if(this.context!=null && this.context.containsKey(org.openspcoop2.core.constants.Costanti.ID_APPLICATIVO_TOKEN)) {
  189.                         idServizioApplicativoToken = (IDServizioApplicativo) this.context.getObject(org.openspcoop2.core.constants.Costanti.ID_APPLICATIVO_TOKEN);
  190.                     }
  191.                     if(idServizioApplicativoToken!=null) {
  192.                         idSA = idServizioApplicativoToken;
  193.                         sa = configIntegrationReader.getServizioApplicativo(idSA);
  194.                     }
  195.                 }
  196.                 
  197.                 ModIValidazioneSintatticaRest validatoreSintatticoRest = null;
  198.                 ModIValidazioneSintatticaSoap validatoreSintatticoSoap = null;
  199.                 if(rest) {
  200.                     validatoreSintatticoRest = new ModIValidazioneSintatticaRest(this.log, this.state, this.context, this.protocolFactory, requestInfo, this.modiProperties, this.validazioneUtils);
  201.                 }
  202.                 else {
  203.                     validatoreSintatticoSoap = new ModIValidazioneSintatticaSoap(this.log, this.state, this.context, this.protocolFactory, requestInfo, this.modiProperties, this.validazioneUtils);
  204.                 }
  205.                 
  206.                 
  207.                 // check Fault
  208.                 boolean isFault = false;
  209.                 if(rest) {
  210.                     isFault = msg.isFault() || msg.castAsRest().isProblemDetailsForHttpApis_RFC7807();  
  211.                 }
  212.                 else {
  213.                     isFault = msg.isFault() || msg.castAsSoap().hasSOAPFault();
  214.                 }
  215.                 
  216.                 
  217.                 
  218.                 // Lettura profili
  219.                 
  220.                 
  221.                 /* *** PROFILO INTERAZIONE *** */
  222.                 
  223.                 String interactionProfile = ModIPropertiesUtils.readPropertyInteractionProfile(aspc, nomePortType, azione);
  224.                 bustaRitornata.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_INTERAZIONE, interactionProfile);
  225.                 
  226.                 if(ModICostanti.MODIPA_PROFILO_INTERAZIONE_VALUE_BLOCCANTE.equals(interactionProfile)) {
  227.                     
  228.                     if(!isFault &&
  229.                         rest) {
  230.                         validatoreSintatticoRest.validateSyncInteractionProfile(msg, request, erroriValidazione);
  231.                     }
  232.                     
  233.                 }
  234.                 else if(ModICostanti.MODIPA_PROFILO_INTERAZIONE_VALUE_NON_BLOCCANTE.equals(interactionProfile)) {
  235.                     
  236.                     String asyncInteractionType = ModIPropertiesUtils.readPropertyAsyncInteractionProfile(aspc, nomePortType, azione);
  237.                     bustaRitornata.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_INTERAZIONE_ASINCRONA_TIPO, asyncInteractionType);
  238.                     
  239.                     String asyncInteractionRole = ModIPropertiesUtils.readPropertyAsyncInteractionRole(aspc, nomePortType, azione);
  240.                     bustaRitornata.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_INTERAZIONE_ASINCRONA_RUOLO, asyncInteractionRole);
  241.                     
  242.                     AccordoServizioParteComune apiContenenteRisorsa = null; 
  243.                     if(!ModICostanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_RUOLO_VALUE_RICHIESTA.equals(asyncInteractionRole)) {
  244.                         
  245.                         if(ModICostanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_VALUE_PUSH.equals(asyncInteractionType)) {
  246.                             String asyncInteractionRequestApi = ModIPropertiesUtils.readPropertyAsyncInteractionRequestApi(aspc, nomePortType, azione);
  247.                             IDAccordo idApiCorrelata = IDAccordoFactory.getInstance().getIDAccordoFromUri(asyncInteractionRequestApi);
  248.                             String labelApi = NamingUtils.getLabelAccordoServizioParteComune(idApiCorrelata);
  249.                             bustaRitornata.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_INTERAZIONE_ASINCRONA_API_RICHIESTA_CORRELATA, labelApi);
  250.                             apiContenenteRisorsa = registryReader.getAccordoServizioParteComune(idApiCorrelata, false, false);
  251.                         }
  252.                         else {
  253.                             apiContenenteRisorsa = aspc;
  254.                         }
  255.                         
  256.                         if(rest) {
  257.                             
  258.                             String asyncInteractionRequestResource = ModIPropertiesUtils.readPropertyAsyncInteractionRequestAction(aspc, nomePortType, azione);
  259.                             
  260.                             String labelResourceCorrelata = asyncInteractionRequestResource;
  261.                             for (Resource r : apiContenenteRisorsa.getResourceList()) {
  262.                                 if(r.getNome().equals(asyncInteractionRequestResource)) {
  263.                                     labelResourceCorrelata = NamingUtils.getLabelResource(r);
  264.                                     break;
  265.                                 }
  266.                             }
  267.                             
  268.                             bustaRitornata.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_INTERAZIONE_ASINCRONA_RISORSA_RICHIESTA_CORRELATA, labelResourceCorrelata);
  269.                             
  270.                         }
  271.                         else {
  272.                             
  273.                             String asyncInteractionRequestService = ModIPropertiesUtils.readPropertyAsyncInteractionRequestService(aspc, nomePortType, azione);
  274.                             bustaRitornata.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_INTERAZIONE_ASINCRONA_SERVIZIO_RICHIESTA_CORRELATA, asyncInteractionRequestService);
  275.                             
  276.                             String asyncInteractionRequestAction = ModIPropertiesUtils.readPropertyAsyncInteractionRequestAction(aspc, nomePortType, azione);
  277.                             bustaRitornata.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_INTERAZIONE_ASINCRONA_AZIONE_RICHIESTA_CORRELATA, asyncInteractionRequestAction);
  278.                             
  279.                         }
  280.                         
  281.                     }
  282.                     else {
  283.                         apiContenenteRisorsa = aspc;
  284.                     }
  285.                     
  286.                     String replyTo = null;
  287.                     if(ModICostanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_RUOLO_VALUE_RICHIESTA.equals(asyncInteractionRole) &&
  288.                         request &&  ModICostanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_VALUE_PUSH.equals(asyncInteractionType)) {
  289.                         // devo cercare l'url di invocazione del servizio fruito correlato.
  290.                         
  291.                         try {
  292.                             replyTo = ModIUtilities.getReplyToFruizione(idServizio.getSoggettoErogatore(), idSoggettoMittente, aspc, nomePortType, azione, 
  293.                                     registryReader, configIntegrationReader, this.protocolFactory, this.state, requestInfo);
  294.                         }catch(Exception e) {
  295.                             throw new ProtocolException("Configurazione presente nel registro non corretta: "+e.getMessage(),e);
  296.                         }
  297.                     }
  298.                     
  299.                     if(!isFault) {
  300.                         if(rest) {
  301.                             validatoreSintatticoRest.validateAsyncInteractionProfile(msg, request, asyncInteractionType, asyncInteractionRole, 
  302.                                     apiContenenteRisorsa, azione,
  303.                                     bustaRitornata, erroriValidazione,
  304.                                     replyTo);
  305.                         }
  306.                         else {
  307.                             validatoreSintatticoSoap.validateAsyncInteractionProfile(msg, request, asyncInteractionType, asyncInteractionRole, 
  308.                                     bustaRitornata, erroriValidazione,
  309.                                     replyTo);
  310.                         }
  311.                     }
  312.                 }
  313.                 
  314.                 /* *** SIGNAL HUB *** */
  315.                 List<ProtocolProperty> protoProps = asps.getProtocolProperty();
  316.                 if (!protoProps.isEmpty() && ProtocolPropertiesUtils.getBooleanValuePropertyRegistry(protoProps, ModICostanti.MODIPA_API_IMPL_INFO_SIGNAL_HUB_ID, false)) {
  317.                     String operation = ProtocolPropertiesUtils.getRequiredStringValuePropertyRegistry(protoProps, ModICostanti.MODIPA_API_IMPL_INFO_SIGNAL_HUB_OPERATION_ID);
  318.                     
  319.                     if (azione.equals(operation)) {
  320.                         this.context.addObject(ModICostanti.MODIPA_KEY_INFO_SIGNAL_HUB_PROPERTIES, protoProps);
  321.                         this.context.addObject(CostantiPdD.KEY_OVERRIDE_CONNETTORE, ModICostanti.MODIPA_CONNETTORE_SIGNAL_HUB_PSEUDONYMIZATION);
  322.                     }
  323.                 }
  324.                 
  325.                 /* *** SICUREZZA CANALE *** */
  326.                 
  327.                 String securityChannelProfile = ModIPropertiesUtils.readPropertySecurityChannelProfile(aspc, asps);
  328.                 bustaRitornata.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_CANALE, securityChannelProfile);
  329.                 
  330.                 if(request && this.context!=null) {
  331.                     
  332.                     @SuppressWarnings("unused")
  333.                     SecurityToken securityTokenForContext = ModIUtilities.newSecurityToken(this.context); // creo per averlo a disposizione anche se non e' presente la sicurezza messaggio
  334.                     
  335.                 }
  336.                 
  337.                 
  338.                 /* *** SICUREZZA MESSAGGIO *** */
  339.                 
  340.                 boolean filterPDND = true;
  341.                 String securityMessageProfileNonFiltratoPDND = ModIPropertiesUtils.readPropertySecurityMessageProfile(aspc, nomePortType, azione, !filterPDND);
  342.                 
  343.                 boolean existsSecurityFlusso =  false;
  344.                 if(securityMessageProfileNonFiltratoPDND!=null && !ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_UNDEFINED.equals(securityMessageProfileNonFiltratoPDND)) {
  345.                     existsSecurityFlusso = ModIPropertiesUtils.processSecurity(this.log,aspc, nomePortType, azione, request, 
  346.                                 msg, rest, this.modiProperties);
  347.                 }
  348.                     
  349.                 if(existsSecurityFlusso) {
  350.                     bustaRitornata.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO, 
  351.                             ModIPropertiesUtils.convertProfiloSicurezzaToSDKValue(securityMessageProfileNonFiltratoPDND, rest));
  352.                     
  353.                     String sorgenteToken = ModIPropertiesUtils.readPropertySecurityMessageSorgenteToken(aspc, nomePortType, azione, true);
  354.                     bustaRitornata.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN,
  355.                             ModIPropertiesUtils.convertProfiloSicurezzaSorgenteTokenToSDKValue(sorgenteToken));
  356.                     boolean sorgenteLocale = true;
  357.                     if(ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN_IDAUTH_VALUE_PDND.equals(sorgenteToken) ||
  358.                             ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN_IDAUTH_VALUE_OAUTH.equals(sorgenteToken)) {
  359.                         sorgenteLocale = false;
  360.                     }
  361.                     
  362.                     String securityMessageProfile = ModIPropertiesUtils.readPropertySecurityMessageProfile(aspc, nomePortType, azione, filterPDND);
  363.                                         
  364.                     MsgDiagnostico msgDiag = null;
  365.                     TipoPdD tipoPdD = request ? TipoPdD.APPLICATIVA : TipoPdD.DELEGATA;
  366.                     IDSoggetto idSoggetto = TipoPdD.DELEGATA.equals(tipoPdD) ? idSoggettoMittente : idServizio.getSoggettoErogatore();
  367.                     if(idSoggetto==null || idSoggetto.getTipo()==null || idSoggetto.getNome()==null) {
  368.                         idSoggetto = OpenSPCoop2Properties.getInstance().getIdentitaPortaDefault(this.protocolFactory.getProtocol(), requestInfo);
  369.                     }
  370.                     else {
  371.                         idSoggetto.setCodicePorta(registryReader.getDominio(idSoggetto));
  372.                     }
  373.                     msgDiag = MsgDiagnostico.newInstance(TipoPdD.DELEGATA, 
  374.                             idSoggetto,
  375.                             "ModI", requestInfo!=null && requestInfo.getProtocolContext()!=null ? requestInfo.getProtocolContext().getInterfaceName() : null,
  376.                             requestInfo,
  377.                             this.state);
  378.                     if(TipoPdD.DELEGATA.equals(tipoPdD)){
  379.                         msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_CONTENUTI_APPLICATIVI);
  380.                     }
  381.                     else {
  382.                         msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_BUSTE);
  383.                     }
  384.                     msgDiag.setPddContext(this.context, this.protocolFactory);
  385.                     String tipoDiagnostico = request ? ".richiesta." : ".risposta.";
  386.                     
  387.                     boolean processSecurity = false;
  388.                     boolean securityMessageProfilePrevedeTokenLocale = securityMessageProfile!=null && !ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_UNDEFINED.equals(securityMessageProfile);
  389.                     if(securityMessageProfilePrevedeTokenLocale) {
  390.                         processSecurity = existsSecurityFlusso;
  391.                     }
  392.                     
  393.                     boolean corniceSicurezza = ModIPropertiesUtils.isPropertySecurityMessageConCorniceSicurezza(aspc, nomePortType, azione);
  394.                     String patternCorniceSicurezza = null;
  395.                     String schemaCorniceSicurezza = null;
  396.                     boolean corniceSicurezzaOpzionale = false;
  397.                     if(corniceSicurezza) {
  398.                         patternCorniceSicurezza = ModIPropertiesUtils.readPropertySecurityMessageCorniceSicurezzaPattern(aspc, nomePortType, azione);
  399.                         if(patternCorniceSicurezza==null) {
  400.                             // backward compatibility
  401.                             patternCorniceSicurezza = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN_VALUE_OLD;
  402.                         }
  403.                         if(!ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN_VALUE_OLD.equals(patternCorniceSicurezza)) {
  404.                             schemaCorniceSicurezza = ModIPropertiesUtils.readPropertySecurityMessageCorniceSicurezzaSchema(aspc, nomePortType, azione);
  405.                             corniceSicurezzaOpzionale = ModIPropertiesUtils.isPropertySecurityMessageCorniceSicurezzaOpzionale(aspc, nomePortType, azione);
  406.                         }
  407.                     }
  408.                     
  409.                     boolean fruizione = !request;
  410.                     
  411.                     boolean processAudit = !fruizione && corniceSicurezza && 
  412.                             patternCorniceSicurezza!=null && !ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN_VALUE_OLD.equals(patternCorniceSicurezza);
  413.                                                 
  414.                     boolean keystoreKidMode = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0401.equals(securityMessageProfile)
  415.                             ||
  416.                             ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0402.equals(securityMessageProfile)
  417.                             ||
  418.                             !sorgenteLocale;
  419.                     
  420.                     Map<String, Object> dynamicMap = null;
  421.                     
  422.                     ModISecurityConfig securityConfig = null;
  423.                     ModISecurityConfig securityConfigAudit = null;                  
  424.                     ModITruststoreConfig trustStoreCertificati = null;
  425.                     ModITruststoreConfig trustStoreSsl = null;
  426.                     
  427.                     String headerTokenRest = null;
  428.                     String headerTokenRestIntegrity = null; // nel caso di Authorization insieme a Agid-JWT-Signature
  429.                     boolean integritaCustom = false;
  430.                     
  431.                     boolean buildSecurityTokenInRequest = true;
  432.                                         
  433.                     if(processSecurity || processAudit) {
  434.                         
  435.                         // dynamicMap
  436.                         // FIX: va inizializzato dentro il metodo 'validateSecurityProfile' dopo aver identificato l'applicativo
  437. /**                     boolean bufferMessage_readOnly = this.modiProperties.isReadByPathBufferEnabled();
  438. //                      Map<String, Object> dynamicMap = null;
  439. //                      Map<String, Object> dynamicMapRequest = null;
  440. //                      if(!request) {
  441. //                          dynamicMapRequest = ModIUtilities.removeDynamicMapRequest(this.context);
  442. //                      }
  443. //                      if(dynamicMapRequest!=null) {
  444. //                          dynamicMap = DynamicUtils.buildDynamicMapResponse(msg, this.context, null, this.log, bufferMessage_readOnly, dynamicMapRequest);
  445. //                      }
  446. //                      else {
  447. //                          dynamicMap = DynamicUtils.buildDynamicMap(msg, this.context, datiRichiesta, this.log, bufferMessage_readOnly);
  448. //                          ModIUtilities.saveDynamicMapRequest(this.context, dynamicMap);
  449. //                      }*/
  450.                         dynamicMap = new HashMap<>();
  451.                         
  452.                         // header
  453.                         Boolean multipleHeaderAuthorizationConfig = null;
  454.                         if(rest) {
  455.                             headerTokenRest = ModIPropertiesUtils.readPropertySecurityMessageHeader(aspc, nomePortType, azione, request, filterPDND);
  456.                             if(headerTokenRest.contains(" ")) {
  457.                                 String [] tmp = headerTokenRest.split(" ");
  458.                                 if(tmp!=null && tmp.length==2 && tmp[0]!=null && tmp[1]!=null) {
  459.                                     headerTokenRest=tmp[0];
  460.                                     headerTokenRestIntegrity=tmp[1];
  461.                                     multipleHeaderAuthorizationConfig = true;
  462.                                 }
  463.                             }
  464.                             integritaCustom = ModIPropertiesUtils.isPropertySecurityMessageHeaderCustom(aspc, nomePortType, azione, request);
  465.                             /**
  466.                              * Lo registro nella busta solamente se lo aggiungo davvero dentro il metodo ModIValidazioneSintatticaRest
  467.                              * 
  468.                              * if(integritaCustom) {
  469.                                 String hdrCustom = headerTokenRest;
  470.                                 if(multipleHeaderAuthorizationConfig!=null && multipleHeaderAuthorizationConfig && headerTokenRestIntegrity!=null) {
  471.                                     hdrCustom = headerTokenRestIntegrity;
  472.                                 }
  473.                                 bustaRitornata.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_CUSTOM_HEADER,hdrCustom);
  474.                             }*/
  475.                         }
  476.                         
  477.                         // security config
  478.                         
  479.                         if(processAudit) {
  480.                             securityConfigAudit = new ModISecurityConfig(msg, this.context, this.protocolFactory, this.state, requestInfo, idSoggettoMittente, 
  481.                                     aspc, asps, sa, rest, fruizione, request,
  482.                                     multipleHeaderAuthorizationConfig,
  483.                                     keystoreKidMode,
  484.                                     patternCorniceSicurezza, schemaCorniceSicurezza);
  485.                         }
  486.                         
  487.                         boolean keystoreKidModeSecurityToken = keystoreKidMode;
  488.                         if(rest && headerTokenRestIntegrity==null) {
  489.                             // un solo header
  490.                             if(ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0301.equals(securityMessageProfile)
  491.                                     ||
  492.                                     ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0302.equals(securityMessageProfile)) {
  493.                                 keystoreKidModeSecurityToken = false;
  494.                             }
  495.                         }
  496.                         
  497.                         securityConfig = new ModISecurityConfig(msg, this.context, this.protocolFactory, this.state, requestInfo, idSoggettoMittente, 
  498.                                 aspc, asps, sa, rest, fruizione, request,
  499.                                 multipleHeaderAuthorizationConfig,
  500.                                 keystoreKidModeSecurityToken,
  501.                                 patternCorniceSicurezza, schemaCorniceSicurezza);
  502.                         
  503.                         // truststore
  504.                         trustStoreCertificati = new ModITruststoreConfig(fruizione, idSoggettoMittente, asps, false);
  505.                         if(securityConfig.isX5u()) {
  506.                             trustStoreSsl = new ModITruststoreConfig(fruizione, idSoggettoMittente, asps, true);
  507.                         }
  508.                         
  509.                         // securityToken
  510.                         if(!request) {
  511.                             String securityMessageRequest = null;
  512.                             if(datiRichiesta!=null) {
  513.                                 securityMessageRequest = datiRichiesta.getProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO);
  514.                             }
  515.                             if(securityMessageRequest==null) {
  516.                                 buildSecurityTokenInRequest = false;
  517.                             }
  518.                             msg.addContextProperty(ModICostanti.MODIPA_OPENSPCOOP2_MSG_CONTEXT_BUILD_SECURITY_REQUEST_TOKEN, buildSecurityTokenInRequest);
  519.                         }
  520.                         else {
  521.                             if(this.context!=null) {
  522.                                 this.context.addObject(ModICostanti.MODIPA_OPENSPCOOP2_MSG_CONTEXT_BUILD_SECURITY_REQUEST_TOKEN, processSecurity);
  523.                             }
  524.                         }
  525.                     }
  526.                     
  527.                     // security (ID_AUTH e INTEGRITY)
  528.                     boolean errorOccurs = false;
  529.                     if(processSecurity) {
  530.                                                                                         
  531.                         boolean includiRequestDigest = ModIPropertiesUtils.isPropertySecurityMessageIncludiRequestDigest(aspc, nomePortType, azione);
  532.                         
  533.                         boolean signAttachments = false;
  534.                         if(!rest) {
  535.                             signAttachments = ModIPropertiesUtils.isAttachmentsSignature(aspc, nomePortType, azione, request, msg);
  536.                         }
  537.                             
  538.                         boolean integritaX509 = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0301.equals(securityMessageProfile) || 
  539.                                 ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0302.equals(securityMessageProfile);
  540.                         boolean integritaKid = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0401.equals(securityMessageProfile) || 
  541.                                 ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0402.equals(securityMessageProfile);
  542.                         boolean integrita = integritaX509 || integritaKid;
  543.                                                 
  544.                         if(rest) {
  545.                             boolean securityHeaderObbligatorio = true;

  547.                             if(headerTokenRestIntegrity==null) {
  548.                                 
  549.                                 String token = null;
  550.                                 String prefixMsgDiag = null;
  551.                                 if(HttpConstants.AUTHORIZATION.equalsIgnoreCase(headerTokenRest)) {
  552.                                     prefixMsgDiag = DIAGNOSTIC_VALIDATE_TOKEN_ID_AUTH;
  553.                                 }
  554.                                 else {
  555.                                     prefixMsgDiag = DIAGNOSTIC_VALIDATE_TOKEN_INTEGRITY;
  556.                                 }
  557.                                 try {
  558.                                     msgDiag.logPersonalizzato(prefixMsgDiag+tipoDiagnostico+DIAGNOSTIC_IN_CORSO);
  559.                                     
  560.                                     // Nel caso di 1 solo header da generare localmente, l'integrity, e l'authorization prodotto tramite token policy, 
  561.                                     //    l'integrity è obbligatorio solo se c'è un payload o se atteso per un integrity cystom. 
  562.                                     //    Nel caso non sia atteso se presente viene validato, altrimenti non da errore.
  563.                                     if(!sorgenteLocale) {
  564.                                         securityHeaderObbligatorio = msg.castAsRest().hasContent() || 
  565.                                                 (integritaCustom && ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_HEADER_CUSTOM_MODE_VALUE_ALWAYS.equals(ModIPropertiesUtils.getPropertySecurityMessageHeaderCustomMode(aspc, nomePortType, azione, request)));
  566.                                     }
  567.                                     token = validatoreSintatticoRest.validateSecurityProfile(msg, request, securityMessageProfile, false, headerTokenRest, 
  568.                                             corniceSicurezza, patternCorniceSicurezza, 
  569.                                             null, // devo fornirlo solo durante la validazione dell'Audit Token 
  570.                                             includiRequestDigest, bustaRitornata, 
  571.                                             erroriValidazione, trustStoreCertificati, trustStoreSsl, securityConfig,
  572.                                             buildSecurityTokenInRequest, ModIHeaderType.SINGLE, integritaCustom, securityHeaderObbligatorio,
  573.                                             dynamicMap, datiRichiesta,
  574.                                             idSoggetto, msgDiag);
  575.                                     
  576.                                     if(token==null && !sorgenteLocale) {
  577.                                         // non c'era un token di integrita nonostante ne sia stato configurato (es. per GET) e sia stato indicato di utilizzarlo come identificativo messaggio.
  578.                                         // per questo motivo in ricezione buste il metodo 'ModIUtils.replaceBustaIdWithJtiTokenId' non è stato invocato
  579.                                         // Utilizzo come identificativo del messaggio quello presente nel voucher.
  580.                                         /** verra' gestito nella validazione semantica, in questa fase il token non e' ancora stato validato 
  581.                                          * String jtiClaimReceived = ModIUtils.readJtiFromInformazioniToken(this.context);
  582.                                         if(jtiClaimReceived!=null && StringUtils.isNotEmpty(jtiClaimReceived) &&
  583.                                                 !jtiClaimReceived.equals(bustaRitornata.getID())) {
  584.                                             bustaRitornata.removeProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_REST_AUTHORIZATION_ID);
  585.                                             bustaRitornata.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_ID, jtiClaimReceived);
  586.                                             if(jtiClaimReceived.length()<=255) {
  587.                                                 bustaRitornata.setID(jtiClaimReceived);
  588.                                             }
  589.                                         }*/
  590.                                     }
  591.                                     
  592.                                     if(erroriValidazione.isEmpty()) {
  593.                                         msgDiag.logPersonalizzato(prefixMsgDiag+tipoDiagnostico+DIAGNOSTIC_COMPLETATA);
  594.                                     }
  595.                                     else {
  596.                                         String errore = buildErrore(erroriValidazione, this.protocolFactory);
  597.                                         msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, errore);
  598.                                         msgDiag.logPersonalizzato(prefixMsgDiag+tipoDiagnostico+DIAGNOSTIC_FALLITA);
  599.                                         errorOccurs = true;
  600.                                     }
  601.                                 }
  602.                                 catch(ProtocolException pe) {
  603.                                     msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, pe.getMessage());
  604.                                     msgDiag.logPersonalizzato(prefixMsgDiag+tipoDiagnostico+DIAGNOSTIC_FALLITA);
  605.                                     throw pe;
  606.                                 }
  607.                                     
  608.                                     
  609.                                 if(token!=null) {
  610.                                     
  611.                                     if(securityConfig.getAudience()!=null &&
  612.                                         (request || (securityConfig.isCheckAudience())) 
  613.                                     ){
  614.                                         String audience = securityConfig.getAudience();
  615.                                         if(fruizione && !request) {
  616.                                             try {
  617.                                                 audience = ModIUtilities.getDynamicValue(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_REST_AUDIENCE, 
  618.                                                         audience, dynamicMap, this.context);
  619.                                             }catch(Exception e) {
  620.                                                 this.logError(e.getMessage(),e);
  621.                                                 throw e;
  622.                                             }
  623.                                         }
  624.                                         msg.addContextProperty(ModICostanti.MODIPA_OPENSPCOOP2_MSG_CONTEXT_AUDIENCE_CHECK, audience);
  625.                                     }
  626.                                     
  627.                                     if(!request && securityConfig.isCheckAudience() && integritaKid && securityConfig.getTokenClientId()!=null) {
  628.                                         String audienceClientId = null;
  629.                                         try {
  630.                                             audienceClientId = ModIUtilities.getDynamicValue(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_REST_AUDIENCE+"-OAuth", 
  631.                                                     securityConfig.getTokenClientId(), dynamicMap, this.context);
  632.                                         }catch(Exception e) {
  633.                                             this.logError(e.getMessage(),e);
  634.                                             throw e;
  635.                                         }
  636.                                         if(audienceClientId!=null) {
  637.                                             msg.addContextProperty(ModICostanti.MODIPA_OPENSPCOOP2_MSG_CONTEXT_AUDIENCE_CHECK_OAUTH, audienceClientId);
  638.                                         }
  639.                                     }
  640.                                     
  641.                                     rawContent = new ModIBustaRawContent(headerTokenRest, token);
  642.                                 }
  643.                             }
  644.                             else {
  645.                                 
  646.                                 boolean useKIDforIdAUTH = false; // normalmente il token authorization sarà PDND, se cmq è locale lo genero uguale per il kid
  647.                                 if(ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0401.equals(securityMessageProfile)
  648.                                         ||
  649.                                         ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0402.equals(securityMessageProfile)) {
  650.                                     useKIDforIdAUTH = true;
  651.                                 }
  652.                                 
  653.                                 // Authorization
  654.                                 String tokenAuthorization = null;
  655.                                 try {
  656.                                     msgDiag.logPersonalizzato(DIAGNOSTIC_VALIDATE_TOKEN_ID_AUTH+tipoDiagnostico+DIAGNOSTIC_IN_CORSO);
  657.                                     
  658.                                     String securityMessageProfileAuthorization = null;
  659.                                     if(ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0301.equals(securityMessageProfile) ||
  660.                                             ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0401.equals(securityMessageProfile)) {
  661.                                         securityMessageProfileAuthorization = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM01; 
  662.                                     }
  663.                                     else {
  664.                                         securityMessageProfileAuthorization = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM02; 
  665.                                     }
  666.                                     tokenAuthorization = validatoreSintatticoRest.validateSecurityProfile(msg, request, securityMessageProfileAuthorization, useKIDforIdAUTH, headerTokenRest, 
  667.                                             corniceSicurezza, patternCorniceSicurezza, 
  668.                                             null, // devo fornirlo solo durante la validazione dell'Audit Token   
  669.                                             includiRequestDigest, bustaRitornata, 
  670.                                             erroriValidazione, trustStoreCertificati, trustStoreSsl, securityConfig,
  671.                                             buildSecurityTokenInRequest, ModIHeaderType.BOTH_AUTH, integritaCustom, securityHeaderObbligatorio,
  672.                                             dynamicMap, datiRichiesta,
  673.                                             idSoggetto, msgDiag);
  674.                                     
  675.                                     String audAuthorization = null;
  676.                                     if(tokenAuthorization!=null &&
  677.                                         securityConfig.getAudience()!=null &&
  678.                                         (request || (securityConfig.isCheckAudience()))
  679.                                         ){
  680.                                         audAuthorization = securityConfig.getAudience();
  681.                                         if(fruizione && !request) {
  682.                                             try {
  683.                                                 audAuthorization = ModIUtilities.getDynamicValue(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_REST_AUDIENCE, 
  684.                                                         audAuthorization, dynamicMap, this.context);
  685.                                             }catch(Exception e) {
  686.                                                 this.logError(e.getMessage(),e);
  687.                                                 throw e;
  688.                                             }
  689.                                         }
  690.                                         msg.addContextProperty(ModICostanti.MODIPA_OPENSPCOOP2_MSG_CONTEXT_AUDIENCE_CHECK, audAuthorization);               
  691.                                     }
  692.                                     
  693.                                     if(erroriValidazione.isEmpty()) {
  694.                                         msgDiag.logPersonalizzato(DIAGNOSTIC_VALIDATE_TOKEN_ID_AUTH+tipoDiagnostico+DIAGNOSTIC_COMPLETATA);
  695.                                     }
  696.                                     else {
  697.                                         String errore = buildErrore(erroriValidazione, this.protocolFactory);
  698.                                         msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, errore);
  699.                                         msgDiag.logPersonalizzato(DIAGNOSTIC_VALIDATE_TOKEN_ID_AUTH+tipoDiagnostico+DIAGNOSTIC_FALLITA);
  700.                                         errorOccurs = true;
  701.                                     }
  702.                                 }
  703.                                 catch(ProtocolException pe) {
  704.                                     msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, pe.getMessage());
  705.                                     msgDiag.logPersonalizzato(DIAGNOSTIC_VALIDATE_TOKEN_ID_AUTH+tipoDiagnostico+DIAGNOSTIC_FALLITA);
  706.                                     throw pe;
  707.                                 }
  708.                                 
  709.                                 // Integrity
  710.                                 String tokenIntegrity = null;
  711.                                 ModISecurityConfig securityConfigIntegrity = null;
  712.                                 try {
  713.                                     msgDiag.logPersonalizzato(DIAGNOSTIC_VALIDATE_TOKEN_INTEGRITY+tipoDiagnostico+DIAGNOSTIC_IN_CORSO);
  714.                                     
  715.                                     // !! Nel caso di 2 header, quello integrity è obbligatorio solo se c'è un payload o se atteso per un integrity cystom. 
  716.                                     //                          Nel caso non sia atteso se presente viene validato, altrimenti non da errore.
  717.                                     boolean securityHeaderIntegrityObbligatorio = msg.castAsRest().hasContent() || 
  718.                                             (integritaCustom && ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_HEADER_CUSTOM_MODE_VALUE_ALWAYS.equals(ModIPropertiesUtils.getPropertySecurityMessageHeaderCustomMode(aspc, nomePortType, azione, request)));
  719.                                             
  720.                                     boolean keystoreKidModeIntegrity = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0401.equals(securityMessageProfile)
  721.                                             ||
  722.                                             ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0402.equals(securityMessageProfile);
  723.                                     securityConfigIntegrity = new ModISecurityConfig(msg, this.context, this.protocolFactory, this.state, requestInfo, idSoggettoMittente, 
  724.                                             aspc, asps, sa, rest, fruizione, request,
  725.                                             false,
  726.                                             keystoreKidModeIntegrity,
  727.                                             patternCorniceSicurezza, schemaCorniceSicurezza);
  728.                                     tokenIntegrity = validatoreSintatticoRest.validateSecurityProfile(msg, request, securityMessageProfile, useKIDforIdAUTH, headerTokenRestIntegrity, 
  729.                                             corniceSicurezza, patternCorniceSicurezza, 
  730.                                             null, // devo fornirlo solo durante la validazione dell'Audit Token 
  731.                                             includiRequestDigest, bustaRitornata, 
  732.                                             erroriValidazione, trustStoreCertificati, trustStoreSsl, securityConfigIntegrity,
  733.                                             buildSecurityTokenInRequest, ModIHeaderType.BOTH_INTEGRITY, integritaCustom, securityHeaderIntegrityObbligatorio,
  734.                                             null, null,
  735.                                             idSoggetto, msgDiag); // gia' inizializzato sopra
  736.                                                 
  737.                                     if(tokenIntegrity==null) {
  738.                                         // non c'era un token di integrita nonostante ne sia stato configurato (es. per GET) e sia stato indicato di utilizzarlo come identificativo messaggio.
  739.                                         // Utilizzo come identificativo del messaggio quello presente nell'authorization.
  740.                                         String idAuth = bustaRitornata.getProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_REST_AUTHORIZATION_ID);
  741.                                         String id = bustaRitornata.getProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_ID);
  742.                                         if( (id ==null || StringUtils.isEmpty(id)) 
  743.                                                 &&  
  744.                                                 idAuth!=null && StringUtils.isNotEmpty(idAuth) &&
  745.                                                 !idAuth.equals(bustaRitornata.getID())) {
  746.                                             bustaRitornata.removeProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_REST_AUTHORIZATION_ID);
  747.                                             bustaRitornata.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_ID, idAuth);
  748.                                             if(idAuth.length()<=255) {
  749.                                                 bustaRitornata.setID(idAuth);
  750.                                             }
  751.                                         }
  752.                                     }
  753.                                     
  754.                                     if(erroriValidazione.isEmpty()) {
  755.                                         msgDiag.logPersonalizzato(DIAGNOSTIC_VALIDATE_TOKEN_INTEGRITY+tipoDiagnostico+DIAGNOSTIC_COMPLETATA);
  756.                                     }
  757.                                     else {
  758.                                         String errore = buildErrore(erroriValidazione, this.protocolFactory);
  759.                                         msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, errore);
  760.                                         msgDiag.logPersonalizzato(DIAGNOSTIC_VALIDATE_TOKEN_INTEGRITY+tipoDiagnostico+DIAGNOSTIC_FALLITA);
  761.                                         errorOccurs = true;
  762.                                     }
  763.                                 }
  764.                                 catch(ProtocolException pe) {
  765.                                     msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, pe.getMessage());
  766.                                     msgDiag.logPersonalizzato(DIAGNOSTIC_VALIDATE_TOKEN_INTEGRITY+tipoDiagnostico+DIAGNOSTIC_FALLITA);
  767.                                     throw pe;
  768.                                 }
  769.                                                                 
  770.                                 if(tokenIntegrity!=null &&
  771.                                     securityConfigIntegrity.getAudience()!=null &&
  772.                                     (request || (securityConfigIntegrity.isCheckAudience())) 
  773.                                     ){
  774.                                     String audIntegrity = securityConfigIntegrity.getAudience();
  775.                                     if(fruizione && !request) {
  776.                                         try {
  777.                                             audIntegrity = ModIUtilities.getDynamicValue(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_REST_AUDIENCE, 
  778.                                                     audIntegrity, dynamicMap, this.context);
  779.                                         }catch(Exception e) {
  780.                                             this.logError(e.getMessage(),e);
  781.                                             throw e;
  782.                                         }
  783.                                     }
  784.                                     msg.addContextProperty(ModICostanti.MODIPA_OPENSPCOOP2_MSG_CONTEXT_AUDIENCE_INTEGRITY_CHECK, audIntegrity);
  785.                                     
  786.                                     if(!request && securityConfig.isCheckAudience() && integritaKid && securityConfig.getTokenClientId()!=null) {
  787.                                         String audienceClientId = null;
  788.                                         try {
  789.                                             audienceClientId = ModIUtilities.getDynamicValue(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_REST_AUDIENCE+"-OAuth", 
  790.                                                     securityConfig.getTokenClientId(), dynamicMap, this.context);
  791.                                         }catch(Exception e) {
  792.                                             this.logError(e.getMessage(),e);
  793.                                             throw e;
  794.                                         }
  795.                                         if(audienceClientId!=null) {
  796.                                             msg.addContextProperty(ModICostanti.MODIPA_OPENSPCOOP2_MSG_CONTEXT_AUDIENCE_INTEGRITY_CHECK_OAUTH, audienceClientId);
  797.                                         }
  798.                                     }
  799.                                 }
  800.                                 
  801.                                 // Finalizzo
  802.                                 
  803.                                 if(tokenAuthorization!=null && tokenIntegrity!=null) {
  804.                                     rawContent = new ModIBustaRawContent(tokenAuthorization, headerTokenRestIntegrity, tokenIntegrity);
  805.                                 }
  806.                                 else if(tokenAuthorization!=null) {
  807.                                     rawContent = new ModIBustaRawContent(headerTokenRest, tokenAuthorization);
  808.                                 }
  809.                                 else if(tokenIntegrity!=null) {
  810.                                     rawContent = new ModIBustaRawContent(headerTokenRestIntegrity, tokenIntegrity);
  811.                                 }
  812.                                 
  813.                             }
  814.                             
  815.                         }
  816.                         else {

  818.                             // soap
  819.                             
  820.                             String prefixMsgDiag = null;
  821.                             if(integrita) {
  822.                                 prefixMsgDiag = DIAGNOSTIC_VALIDATE_TOKEN_INTEGRITY;
  823.                             }
  824.                             else {
  825.                                 prefixMsgDiag = DIAGNOSTIC_VALIDATE_TOKEN_ID_AUTH;
  826.                             }
  827.                             try {
  828.                                 msgDiag.logPersonalizzato(prefixMsgDiag+tipoDiagnostico+DIAGNOSTIC_IN_CORSO);
  829.                             
  830.                                 boolean corniceSicurezzaLegacySoap = corniceSicurezza && !processAudit;
  831.                                 
  832.                                 SOAPEnvelope token = validatoreSintatticoSoap.validateSecurityProfile(msg, request, securityMessageProfile, corniceSicurezzaLegacySoap, includiRequestDigest, signAttachments, bustaRitornata, 
  833.                                         erroriValidazione, trustStoreCertificati, securityConfig,
  834.                                         buildSecurityTokenInRequest,
  835.                                         dynamicMap, datiRichiesta, requestInfo, msgDiag );
  836.                                 
  837.                                 if(token!=null) {
  838.                                     
  839.                                     if(securityConfig.getAudience()!=null &&
  840.                                         (request || (securityConfig.isCheckAudience())) 
  841.                                         ){
  842.                                         String audience = securityConfig.getAudience();
  843.                                         if(fruizione && !request) {
  844.                                             try {
  845.                                                 audience = ModIUtilities.getDynamicValue(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_SOAP_WSA_TO, 
  846.                                                         audience, dynamicMap, this.context);
  847.                                             }catch(Exception e) {
  848.                                                 this.logError(e.getMessage(),e);
  849.                                                 throw e;
  850.                                             }
  851.                                         }
  852.                                         msg.addContextProperty(ModICostanti.MODIPA_OPENSPCOOP2_MSG_CONTEXT_AUDIENCE_CHECK, audience);
  853.                                     }
  854.                                     
  855.                                     rawContent = new ModIBustaRawContent(token);
  856.                                 }

  858.                                 if(erroriValidazione.isEmpty()) {
  859.                                     msgDiag.logPersonalizzato(prefixMsgDiag+tipoDiagnostico+DIAGNOSTIC_COMPLETATA);
  860.                                 }
  861.                                 else {
  862.                                     String errore = buildErrore(erroriValidazione, this.protocolFactory);
  863.                                     msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, errore);
  864.                                     msgDiag.logPersonalizzato(prefixMsgDiag+tipoDiagnostico+DIAGNOSTIC_FALLITA);
  865.                                     errorOccurs = true;
  866.                                 }
  867.                             }
  868.                             catch(ProtocolException pe) {
  869.                                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, pe.getMessage());
  870.                                 msgDiag.logPersonalizzato(prefixMsgDiag+tipoDiagnostico+DIAGNOSTIC_FALLITA);
  871.                                 throw pe;
  872.                             }
  873.                             
  874.                         }
  875.                     
  876.                     }
  877.                     
  878.                     // audit (ID_AUDIT)
  879.                     if(!errorOccurs && processAudit) {
  880.                         
  881.                         bustaRitornata.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_AUDIT_PATTERN, 
  882.                                 ModIPropertiesUtils.convertProfiloAuditToSDKValue(patternCorniceSicurezza));
  883.                         bustaRitornata.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_AUDIT_SCHEMA, 
  884.                                 ModIPropertiesUtils.convertSchemaAuditToSDKValue(schemaCorniceSicurezza, this.modiProperties));
  885.                         
  886.                         if(validatoreSintatticoRest==null) {
  887.                             // audit su api soap
  888.                             validatoreSintatticoRest = new ModIValidazioneSintatticaRest(this.log, this.state, this.context, this.protocolFactory, requestInfo, this.modiProperties, this.validazioneUtils);
  889.                         }
  890.                         
  891.                         String securityMessageProfileAudit = null;
  892.                         if(ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0301.equals(securityMessageProfile)
  893.                                 ||
  894.                                 ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0401.equals(securityMessageProfile)) {
  895.                             securityMessageProfileAudit = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM01; 
  896.                         }
  897.                         else {
  898.                             securityMessageProfileAudit = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM02; 
  899.                         }
  900.                                                 
  901.                         boolean useKIDforAudit = false;
  902.                         if(ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0401.equals(securityMessageProfile)
  903.                                 ||
  904.                                 ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0402.equals(securityMessageProfile)
  905.                                 ||
  906.                                 !sorgenteLocale) {
  907.                             useKIDforAudit = true;
  908.                         }
  909.                         
  910.                         String headerTokenAudit = this.modiProperties.getSecurityTokenHeaderModIAudit();
  911.                         
  912.                         try {
  913.                             msgDiag.logPersonalizzato("validateTokenAudit.richiesta.inCorso");
  914.                         
  915.                             boolean securityHeaderObbligatorio = !corniceSicurezzaOpzionale;
  916.                             
  917.                             String tokenAudit = validatoreSintatticoRest.validateSecurityProfile(msg, request, securityMessageProfileAudit, useKIDforAudit, headerTokenAudit, 
  918.                                     corniceSicurezza, patternCorniceSicurezza, schemaCorniceSicurezza,
  919.                                     false, bustaRitornata, 
  920.                                     erroriValidazione, trustStoreCertificati, trustStoreSsl, securityConfigAudit,
  921.                                     buildSecurityTokenInRequest, ModIHeaderType.SINGLE, integritaCustom, securityHeaderObbligatorio,
  922.                                     dynamicMap, datiRichiesta,
  923.                                     idSoggetto, msgDiag);
  924.                             
  925.                             if(tokenAudit!=null){
  926.                                 String audExpected = securityConfig.getCorniceSicurezzaAudience();
  927.                                 try {
  928.                                     audExpected = ModIUtilities.getDynamicValue(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_AUDIT_AUDIENCE, 
  929.                                             audExpected, dynamicMap, this.context);
  930.                                 }catch(Exception e) {
  931.                                     this.logError(e.getMessage(),e);
  932.                                     throw e;
  933.                                 }
  934.                                 msg.addContextProperty(ModICostanti.MODIPA_OPENSPCOOP2_MSG_CONTEXT_AUDIENCE_AUDIT_CHECK, audExpected);              
  935.                             }
  936.                             
  937.                             if(rawContent!=null) {
  938.                                 rawContent.getElement().setTokenAudit(headerTokenAudit, tokenAudit);
  939.                             }
  940.                             
  941.                             if(erroriValidazione.isEmpty()) {
  942.                                 msgDiag.logPersonalizzato("validateTokenAudit.richiesta.completata");
  943.                             }
  944.                             else {
  945.                                 String errore = buildErrore(erroriValidazione, this.protocolFactory);
  946.                                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, errore);
  947.                                 msgDiag.logPersonalizzato("validateTokenAudit.richiesta.fallita");
  948.                             }
  949.                         }
  950.                         catch(ProtocolException pe) {
  951.                             msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, pe.getMessage());
  952.                             msgDiag.logPersonalizzato("validateTokenAudit.richiesta.fallita");
  953.                             throw pe;
  954.                         }
  955.                         
  956.                     }
  957.                     
  958.                     
  959.                     // jit as filtro duplicato
  960.                     if(request && !sorgenteLocale) {
  961.                         if(processSecurity) {
  962.                             String idPropertyMultipleHeaderUseJtiAuthorizationAsIdMessaggio = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_RICHIESTA_REST_DOPPI_HEADER_FILTRO_DUPLICATI;
  963.                             List<ProtocolProperty> listProtocolPropertiesInternal = ModIPropertiesUtils.getProtocolProperties(fruizione, idSoggettoMittente, asps);
  964.                             if(listProtocolPropertiesInternal!=null && !listProtocolPropertiesInternal.isEmpty()) {
  965.                                 String multipleHeaderUseJtiAuthorizationAsIdMessaggioPropRegistry = ProtocolPropertiesUtils.getOptionalStringValuePropertyRegistry(listProtocolPropertiesInternal, idPropertyMultipleHeaderUseJtiAuthorizationAsIdMessaggio);
  966.                                 if(multipleHeaderUseJtiAuthorizationAsIdMessaggioPropRegistry!=null) {
  967.                                     boolean multipleHeaderUseJtiAuthorizationAsIdMessaggio = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_REST_DOPPI_HEADER_FILTRO_DUPLICATI_VALUE_AUTHORIZATION.equals(multipleHeaderUseJtiAuthorizationAsIdMessaggioPropRegistry);
  968.                                     msg.addContextProperty(ModICostanti.MODIPA_OPENSPCOOP2_MSG_CONTEXT_USE_JTI_AUTHORIZATION, multipleHeaderUseJtiAuthorizationAsIdMessaggio);
  969.                                 }
  970.                             }
  971.                         }
  972.                         else {
  973.                             msg.addContextProperty(ModICostanti.MODIPA_OPENSPCOOP2_MSG_CONTEXT_USE_JTI_AUTHORIZATION, true);
  974.                         }
  975.                     }
  976.                 }

  978.             }
  979.                         
  980.         }catch(Exception e) {
  981.             erroreProcessamentoInternalMessage = e.getMessage();
  982.             String msgErrore =  "[ErroreInterno]: "+e.getMessage();
  983.             this.logError(msgErrore,e);
  984.             if(request) {
  985.                 ValidazioneSintatticaResult<AbstractModISecurityToken<?>> errorResult = new ValidazioneSintatticaResult<>(null, null, null, 
  986.                         bustaRitornata, new ErroreCooperazione(msgErrore, CodiceErroreCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO), null, null, false);
  987.                 errorResult.setErrore_integrationFunctionError(IntegrationFunctionError.INTERNAL_REQUEST_ERROR);
  988.                 return errorResult;
  989.             }
  990.             else {
  991.                 try {
  992.                     erroriProcessamento.add(this.validazioneUtils.newEccezioneProcessamento(CodiceErroreCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO));
  993.                 }catch(Exception eInternal) {
  994.                     ValidazioneSintatticaResult<AbstractModISecurityToken<?>> errorResult = new ValidazioneSintatticaResult<>(null, null, null, 
  995.                             bustaRitornata, new ErroreCooperazione(msgErrore, CodiceErroreCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO), null, null, false);
  996.                     errorResult.setErrore_integrationFunctionError(IntegrationFunctionError.INTERNAL_RESPONSE_ERROR);
  997.                     return errorResult;
  998.                 }
  999.             }
  1000.         }
  1001.         
  1002.         if(!erroriValidazione.isEmpty() || !erroriProcessamento.isEmpty()) {
  1003.             ValidazioneSintatticaResult<AbstractModISecurityToken<?>> resultError = new ValidazioneSintatticaResult<>(erroriValidazione, erroriProcessamento, null, 
  1004.                     bustaRitornata, null, null, rawContent, true);
  1005.             resultError.setErroreProcessamento_internalMessage(erroreProcessamentoInternalMessage);
  1006.             
  1007.             if(!erroriValidazione.isEmpty() &&
  1008.                 this.context!=null) {
  1009.                 this.context.addObject(Costanti.ERRORE_VALIDAZIONE_PROTOCOLLO, Costanti.ERRORE_TRUE);
  1010.             }
  1011.             
  1012.             return resultError;
  1013.         }
  1014.         
  1015.         basicResult.setBustaRaw(rawContent);
  1016.         return basicResult;
  1017.     }
  1018.     
  1019.     static String buildErrore(List<Eccezione> list, IProtocolFactory<?> protocolFactory) throws ProtocolException {
  1020.         return buildErrore(list, 0, protocolFactory);
  1021.     }
  1022.     static String buildErrore(List<Eccezione> list, int offset, IProtocolFactory<?> protocolFactory) throws ProtocolException {
  1023.         StringBuilder sb = new StringBuilder();
  1024.         if(list!=null && !list.isEmpty()) {
  1025.             if(list.size()==1) {
  1026.                 if(offset>0) {
  1027.                     throw new ProtocolException("Offset > 0 con lista di dimensione '"+list.size()+"'");
  1028.                 }
  1029.                 Eccezione eccezione = list.get(0);
  1030.                 sb.append("[");
  1031.                 sb.append(eccezione.getCodiceEccezioneValue(protocolFactory));
  1032.                 sb.append("] ");
  1033.                 sb.append(eccezione.getDescrizione(protocolFactory));
  1034.             }
  1035.             else {
  1036.                 if(offset>list.size()) {
  1037.                     throw new ProtocolException("Offset maggiore della dimensione della lista di errori '"+list.size()+"'");
  1038.                 }
  1039.                 int size = list.size() - offset;
  1040.                 sb.append("Riscontrate "+size+" eccezioni.");
  1041.                 int index = 0;
  1042.                 for (Eccezione eccezione : list) {
  1043.                     if(index>=offset) {
  1044.                         sb.append("\n[");
  1045.                         sb.append(eccezione.getCodiceEccezioneValue(protocolFactory));
  1046.                         sb.append("] ");
  1047.                         sb.append(eccezione.getDescrizione(protocolFactory));
  1048.                     }
  1049.                     index++;
  1050.                 }
  1051.             }
  1052.         }
  1053.         return sb.toString();
  1054.     }
  1055. }
Created with JaCoCo 0.8.8.202204050719