ModIImbustamento.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.builder;

  23. import java.io.IOException;
  24. import java.util.List;
  25. import java.util.Map;

  27. import javax.servlet.http.HttpServletResponse;
  28. import javax.xml.soap.SOAPEnvelope;

  30. import org.apache.commons.lang.StringUtils;
  31. import org.openspcoop2.core.config.ServizioApplicativo;
  32. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  33. import org.openspcoop2.core.config.driver.db.DriverConfigurazioneDB;
  34. import org.openspcoop2.core.constants.Costanti;
  35. import org.openspcoop2.core.constants.TipoPdD;
  36. import org.openspcoop2.core.id.IDAccordo;
  37. import org.openspcoop2.core.id.IDServizio;
  38. import org.openspcoop2.core.id.IDServizioApplicativo;
  39. import org.openspcoop2.core.id.IDSoggetto;
  40. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  41. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  42. import org.openspcoop2.core.registry.ProtocolProperty;
  43. import org.openspcoop2.core.registry.Resource;
  44. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  45. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  46. import org.openspcoop2.message.OpenSPCoop2Message;
  47. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  48. import org.openspcoop2.message.constants.MessageRole;
  49. import org.openspcoop2.pdd.config.ConfigurazionePdDReader;
  50. import org.openspcoop2.pdd.config.DigestServiceParams;
  51. import org.openspcoop2.pdd.config.DigestServiceParamsDriver;
  52. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  53. import org.openspcoop2.pdd.core.CostantiPdD;
  54. import org.openspcoop2.pdd.core.dynamic.DynamicUtils;
  55. import org.openspcoop2.pdd.core.token.PolicyNegoziazioneToken;
  56. import org.openspcoop2.pdd.core.transazioni.Transaction;
  57. import org.openspcoop2.pdd.core.transazioni.TransactionContext;
  58. import org.openspcoop2.pdd.core.transazioni.TransactionNotExistsException;
  59. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  60. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  61. import org.openspcoop2.protocol.engine.utils.NamingUtils;
  62. import org.openspcoop2.protocol.modipa.ModIBustaRawContent;
  63. import org.openspcoop2.protocol.modipa.config.ModIProperties;
  64. import org.openspcoop2.protocol.modipa.constants.ModICostanti;
  65. import org.openspcoop2.protocol.modipa.constants.ModIHeaderType;
  66. import org.openspcoop2.protocol.modipa.constants.ModISignalHubOperation;
  67. import org.openspcoop2.protocol.modipa.utils.MockHttpServletRequest;
  68. import org.openspcoop2.protocol.modipa.utils.MockHttpServletResponse;
  69. import org.openspcoop2.protocol.modipa.utils.MockServletInputStream;
  70. import org.openspcoop2.protocol.modipa.utils.MockServletOutputStream;
  71. import org.openspcoop2.protocol.modipa.utils.ModIKeystoreConfig;
  72. import org.openspcoop2.protocol.modipa.utils.ModIPropertiesUtils;
  73. import org.openspcoop2.protocol.modipa.utils.ModISecurityConfig;
  74. import org.openspcoop2.protocol.modipa.utils.ModIUtilities;
  75. import org.openspcoop2.protocol.modipa.utils.SignalHubUtils;
  76. import org.openspcoop2.protocol.sdk.Busta;
  77. import org.openspcoop2.protocol.sdk.ConfigurazionePdD;
  78. import org.openspcoop2.protocol.sdk.Context;
  79. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  80. import org.openspcoop2.protocol.sdk.ProtocolException;
  81. import org.openspcoop2.protocol.sdk.ProtocolMessage;
  82. import org.openspcoop2.protocol.sdk.constants.RuoloMessaggio;
  83. import org.openspcoop2.protocol.sdk.properties.ProtocolPropertiesUtils;
  84. import org.openspcoop2.protocol.sdk.registry.IConfigIntegrationReader;
  85. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  86. import org.openspcoop2.protocol.sdk.state.IState;
  87. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  88. import org.openspcoop2.protocol.utils.IDSerialGenerator;
  89. import org.openspcoop2.utils.MapKey;
  90. import org.openspcoop2.utils.UtilsException;
  91. import org.openspcoop2.utils.certificate.KeystoreParams;
  92. import org.openspcoop2.utils.date.DateManager;
  93. import org.openspcoop2.utils.digest.DigestConfig;
  94. import org.openspcoop2.utils.digest.DigestFactory;
  95. import org.openspcoop2.utils.digest.IDigest;
  96. import org.openspcoop2.utils.id.UniqueIdentifierManager;
  97. import org.openspcoop2.utils.id.serial.IDSerialGeneratorParameter;
  98. import org.openspcoop2.utils.id.serial.IDSerialGeneratorType;
  99. import org.openspcoop2.utils.json.JSONUtils;
  100. import org.openspcoop2.utils.transport.TransportRequestContext;
  101. import org.openspcoop2.utils.transport.http.HttpConstants;
  102. import org.slf4j.Logger;

  104. import com.fasterxml.jackson.databind.JsonNode;
  105. import com.fasterxml.jackson.databind.node.ObjectNode;

  107. /**
  108.  * ModIImbustamento
  109.  *
  110.  * @author Poli Andrea (apoli@link.it)
  111.  * @author $Author$
  112.  * @version $Rev$, $Date$
  113.  */
  114. public class ModIImbustamento {

  116.     private Logger log;
  117.     private ModIProperties modiProperties;
  118.     public ModIImbustamento(Logger log) throws ProtocolException {
  119.         this.log = log;
  120.         this.modiProperties = ModIProperties.getInstance();
  121.     }
  122.     
  123.     private static final String DIAGNOSTIC_ADD_TOKEN_ID_AUTH = "addTokenIdAuth";
  124.     private static final String DIAGNOSTIC_ADD_TOKEN_INTEGRITY = "addTokenIntegrity";
  125.     private static final String DIAGNOSTIC_IN_CORSO = "inCorso";
  126.     private static final String DIAGNOSTIC_COMPLETATA = "completata";
  127.     private static final String DIAGNOSTIC_FALLITA = "fallita";
  128.     
  129.     private static String getReplyToErogazione(IDSoggetto idSoggettoMittente, AccordoServizioParteComune aspc, String nomePortType, String azione,
  130.             IRegistryReader registryReader, IConfigIntegrationReader configIntegrationReader, 
  131.             IProtocolFactory<?> protocolFactory, IState state,
  132.             RequestInfo requestInfo) throws ProtocolException {
  133.         try {
  134.             return ModIUtilities.getReplyToErogazione(idSoggettoMittente, aspc, nomePortType, azione, 
  135.                     registryReader, configIntegrationReader, protocolFactory, state, requestInfo);
  136.         }catch(Exception e) {
  137.             throw new ProtocolException("Configurazione presente nel registro non corretta: "+e.getMessage(),e);
  138.         }
  139.     }
  140.     
  141.     private static String newUniqueIdentifier() throws ProtocolException {
  142.         try{
  143.             return UniqueIdentifierManager.newUniqueIdentifier().getAsString();
  144.         }catch(Exception e){
  145.             throw new ProtocolException(e.getMessage());
  146.         }
  147.     }
  148.     
  149.     public ProtocolMessage buildMessage(OpenSPCoop2Message msg, Context context, Busta busta, Busta bustaRichiesta,
  150.             RuoloMessaggio ruoloMessaggio,
  151.             IRegistryReader registryReader, IConfigIntegrationReader configIntegrationReader, 
  152.             IProtocolFactory<?> protocolFactory, IState state) throws ProtocolException{
  153.         
  154.         try{
  155.             ProtocolMessage protocolMessage = new ProtocolMessage();
  156.             
  157.             MessageRole messageRole = MessageRole.REQUEST;
  158.             if(RuoloMessaggio.RISPOSTA.equals(ruoloMessaggio)){
  159.                 messageRole = MessageRole.RESPONSE; 
  160.             }
  161.             
  162.             
  163.             // **** Read object from Registry *****
  164.             
  165.             IDSoggetto idSoggettoMittente = new IDSoggetto(busta.getTipoMittente(),busta.getMittente());
  166.             IDSoggetto idSoggettoDestinatario = new IDSoggetto(busta.getTipoDestinatario(),busta.getDestinatario());
  167.             IDSoggetto idSoggettoErogatore = null;
  168.             IDSoggetto idSoggettoProprietarioSA = null;
  169.             if(RuoloMessaggio.RICHIESTA.equals(ruoloMessaggio)){ 
  170.                 idSoggettoErogatore = idSoggettoDestinatario;
  171.                 idSoggettoProprietarioSA = idSoggettoMittente;
  172.             }
  173.             else{
  174.                 idSoggettoErogatore = idSoggettoMittente;
  175.                 idSoggettoProprietarioSA = idSoggettoDestinatario;
  176.             }
  177.             IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(busta.getTipoServizio(), busta.getServizio(), 
  178.                     idSoggettoErogatore, busta.getVersioneServizio());
  179.             AccordoServizioParteSpecifica asps = registryReader.getAccordoServizioParteSpecifica(idServizio);
  180.             
  181.             IDAccordo idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromUri(asps.getAccordoServizioParteComune());
  182.             AccordoServizioParteComune aspc = registryReader.getAccordoServizioParteComune(idAccordo);
  183.             boolean rest = org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(aspc.getServiceBinding());
  184.             
  185.             IDServizioApplicativo idSA = null;
  186.             ServizioApplicativo sa = null;
  187.             if(MessageRole.REQUEST.equals(messageRole) &&
  188.                     busta.getServizioApplicativoFruitore()!=null && 
  189.                     !CostantiPdD.SERVIZIO_APPLICATIVO_ANONIMO.equals(busta.getServizioApplicativoFruitore())) {
  190.                 idSA = new IDServizioApplicativo();
  191.                 idSA.setIdSoggettoProprietario(idSoggettoProprietarioSA);
  192.                 idSA.setNome(busta.getServizioApplicativoFruitore());
  193.                 sa = configIntegrationReader.getServizioApplicativo(idSA);
  194.             }
  195.             if(MessageRole.REQUEST.equals(messageRole) && sa==null) {
  196.                 // provo a vedere se autenticato tramite autenticazione token
  197.                 IDServizioApplicativo idServizioApplicativoToken = null;
  198.                 if(context!=null && context.containsKey(org.openspcoop2.core.constants.Costanti.ID_APPLICATIVO_TOKEN)) {
  199.                     idServizioApplicativoToken = (IDServizioApplicativo) context.getObject(org.openspcoop2.core.constants.Costanti.ID_APPLICATIVO_TOKEN);
  200.                 }
  201.                 if(idServizioApplicativoToken!=null) {
  202.                     idSA = idServizioApplicativoToken;
  203.                     sa = configIntegrationReader.getServizioApplicativo(idSA);
  204.                 }
  205.             }
  206.             
  207.             String azione = busta.getAzione();
  208.             String nomePortType = asps.getPortType();
  209.             
  210.             RequestInfo requestInfo = null;
  211.             if(context!=null && context.containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  212.                 requestInfo = (RequestInfo) context.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  213.             }
  214.             
  215.             ModIImbustamentoRest imbustamentoRest = null;
  216.             ModIImbustamentoSoap imbustamentoSoap = null;
  217.             if(rest) {
  218.                 imbustamentoRest = new ModIImbustamentoRest(this.log);
  219.             }
  220.             else {
  221.                 imbustamentoSoap = new ModIImbustamentoSoap(this.log);
  222.             }
  223.             
  224.             
  225.             
  226.             /* *** PROFILO INTERAZIONE *** */
  227.             
  228.             String interactionProfile = ModIPropertiesUtils.readPropertyInteractionProfile(aspc, nomePortType, azione);
  229.             busta.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_INTERAZIONE, interactionProfile);
  230.             
  231.             if(ModICostanti.MODIPA_PROFILO_INTERAZIONE_VALUE_BLOCCANTE.equals(interactionProfile)) {
  232.             
  233.                 if(rest) {
  234.                     imbustamentoRest.addSyncInteractionProfile(msg, ruoloMessaggio);
  235.                 }
  236.                 
  237.             }
  238.             else if(ModICostanti.MODIPA_PROFILO_INTERAZIONE_VALUE_NON_BLOCCANTE.equals(interactionProfile)) {
  239.                 
  240.                 String asyncInteractionType = ModIPropertiesUtils.readPropertyAsyncInteractionProfile(aspc, nomePortType, azione);
  241.                 busta.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_INTERAZIONE_ASINCRONA_TIPO, asyncInteractionType);
  242.                 
  243.                 String asyncInteractionRole = ModIPropertiesUtils.readPropertyAsyncInteractionRole(aspc, nomePortType, azione);
  244.                 busta.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_INTERAZIONE_ASINCRONA_RUOLO, asyncInteractionRole);
  245.                 
  246.                 String replyTo = null;
  247.                 
  248.                 AccordoServizioParteComune apiContenenteRisorsa = null; 
  249.                                 
  250.                 if(ModICostanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_RUOLO_VALUE_RICHIESTA.equals(asyncInteractionRole)) {
  251.                 
  252.                     if(RuoloMessaggio.RICHIESTA.equals(ruoloMessaggio) && ModICostanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_VALUE_PUSH.equals(asyncInteractionType)) {
  253.                         // devo cercare l'url di invocazione del servizio erogato correlato.
  254.                         
  255.                         replyTo = getReplyToErogazione(idSoggettoMittente, aspc, nomePortType, azione,
  256.                                 registryReader, configIntegrationReader, 
  257.                                 protocolFactory, state,
  258.                                 requestInfo);
  259.                     }
  260.                     
  261.                     apiContenenteRisorsa = aspc;
  262.                     
  263.                 }
  264.                 else {
  265.                     
  266.                     if(ModICostanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_VALUE_PUSH.equals(asyncInteractionType)) {
  267.                         String asyncInteractionRequestApi = ModIPropertiesUtils.readPropertyAsyncInteractionRequestApi(aspc, nomePortType, azione);
  268.                         IDAccordo idApiCorrelata = IDAccordoFactory.getInstance().getIDAccordoFromUri(asyncInteractionRequestApi);
  269.                         String labelApi = NamingUtils.getLabelAccordoServizioParteComune(idApiCorrelata);
  270.                         busta.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_INTERAZIONE_ASINCRONA_API_RICHIESTA_CORRELATA, labelApi);
  271.                         apiContenenteRisorsa = registryReader.getAccordoServizioParteComune(idApiCorrelata, false, false);
  272.                     }
  273.                     else {
  274.                         apiContenenteRisorsa = aspc;
  275.                     }
  276.                     
  277.                     if(rest) {
  278.                         
  279.                         String asyncInteractionRequestResource = ModIPropertiesUtils.readPropertyAsyncInteractionRequestAction(aspc, nomePortType, azione);
  280.                                                 
  281.                         String labelResourceCorrelata = asyncInteractionRequestResource;
  282.                         for (Resource r : apiContenenteRisorsa.getResourceList()) {
  283.                             if(r.getNome().equals(asyncInteractionRequestResource)) {
  284.                                 labelResourceCorrelata = NamingUtils.getLabelResource(r);
  285.                                 break;
  286.                             }
  287.                         }
  288.                         
  289.                         busta.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_INTERAZIONE_ASINCRONA_RISORSA_RICHIESTA_CORRELATA, labelResourceCorrelata);
  290.                         
  291.                     }
  292.                     else {
  293.                         
  294.                         String asyncInteractionRequestService = ModIPropertiesUtils.readPropertyAsyncInteractionRequestService(aspc, nomePortType, azione);
  295.                         busta.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_INTERAZIONE_ASINCRONA_SERVIZIO_RICHIESTA_CORRELATA, asyncInteractionRequestService);
  296.                         
  297.                         String asyncInteractionRequestAction = ModIPropertiesUtils.readPropertyAsyncInteractionRequestAction(aspc, nomePortType, azione);
  298.                         busta.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_INTERAZIONE_ASINCRONA_AZIONE_RICHIESTA_CORRELATA, asyncInteractionRequestAction);
  299.                         
  300.                     }
  301.                     
  302.                 }
  303.                 
  304.                 if(rest) {
  305.                     imbustamentoRest.addAsyncInteractionProfile(msg, busta, ruoloMessaggio, 
  306.                             asyncInteractionType, asyncInteractionRole,
  307.                             replyTo,
  308.                             apiContenenteRisorsa, azione);
  309.                 }
  310.                 else {
  311.                     imbustamentoSoap.addAsyncInteractionProfile(msg, busta, ruoloMessaggio, 
  312.                             asyncInteractionType, asyncInteractionRole,
  313.                             replyTo,
  314.                             apiContenenteRisorsa, azione);
  315.                 }
  316.                 
  317.             }
  318.             
  319.             /* *** SIGNAL HUB PUSH SIGNALS *** */   
  320.             if (RuoloMessaggio.RICHIESTA.equals(ruoloMessaggio)
  321.                     && context.containsKey(ModICostanti.MODIPA_KEY_INFO_SIGNAL_HUB_SIGNAL_TYPE)) {
  322.                 msg = this.computeSignalHubMessage(msg, context, protocolFactory, state);
  323.             }
  324.             
  325.             
  326.             /* *** SICUREZZA CANALE *** */
  327.             
  328.             String securityChannelProfile = ModIPropertiesUtils.readPropertySecurityChannelProfile(aspc, asps);
  329.             busta.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_CANALE, securityChannelProfile);
  330.             
  331.             
  332.             /* *** SICUREZZA MESSAGGIO *** */
  333.             
  334.             boolean isRichiesta = MessageRole.REQUEST.equals(messageRole);
  335.             
  336.             
  337.             boolean filterPDND = true;
  338.             String securityMessageProfileNonFiltratoPDND = ModIPropertiesUtils.readPropertySecurityMessageProfile(aspc, nomePortType, azione, !filterPDND);
  339.             
  340.             boolean existsSecurityFlusso =  false;
  341.             if(securityMessageProfileNonFiltratoPDND!=null && !ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_UNDEFINED.equals(securityMessageProfileNonFiltratoPDND)) {
  342.                 existsSecurityFlusso = ModIPropertiesUtils.processSecurity(this.log, aspc, nomePortType, azione, isRichiesta, 
  343.                         msg, rest, this.modiProperties);
  344.             }
  345.             
  346.             if(existsSecurityFlusso) {
  347.                 
  348.                 busta.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO,
  349.                         ModIPropertiesUtils.convertProfiloSicurezzaToSDKValue(securityMessageProfileNonFiltratoPDND, rest));
  350.                 
  351.                 String sorgenteToken = ModIPropertiesUtils.readPropertySecurityMessageSorgenteToken(aspc, nomePortType, azione, true);
  352.                 busta.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN,
  353.                         ModIPropertiesUtils.convertProfiloSicurezzaSorgenteTokenToSDKValue(sorgenteToken));
  354.                 boolean sorgenteLocale = true;
  355.                 if(ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN_IDAUTH_VALUE_PDND.equals(sorgenteToken) ||
  356.                         ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN_IDAUTH_VALUE_OAUTH.equals(sorgenteToken)) {
  357.                     sorgenteLocale = false;
  358.                 }
  359.                 
  360.                 String securityMessageProfile = ModIPropertiesUtils.readPropertySecurityMessageProfile(aspc, nomePortType, azione, filterPDND);
  361.                 
  362.                 boolean sicurezzaRidefinitaOperazione = ModIPropertiesUtils.readSicurezzaMessaggioRidefinitaOperazioneEngine(aspc, nomePortType, azione);
  363.                                 
  364.                 MsgDiagnostico msgDiag = null;
  365.                 TipoPdD tipoPdD = RuoloMessaggio.RICHIESTA.equals(ruoloMessaggio) ? TipoPdD.DELEGATA : TipoPdD.APPLICATIVA;
  366.                 IDSoggetto idSoggetto = TipoPdD.DELEGATA.equals(tipoPdD) ? idSoggettoMittente : idSoggettoDestinatario;
  367.                 if(idSoggetto==null || idSoggetto.getTipo()==null || idSoggetto.getNome()==null) {
  368.                     idSoggetto = OpenSPCoop2Properties.getInstance().getIdentitaPortaDefault(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.                         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(context, protocolFactory);
  385.                 String tipoDiagnostico = RuoloMessaggio.RICHIESTA.equals(ruoloMessaggio) ? ".richiesta." : ".risposta.";
  386.                 
  387.                 // check config
  388.                 
  389.                 boolean addSecurity = false;
  390.                 boolean securityMessageProfilePrevedeTokenLocale = securityMessageProfile!=null && !ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_UNDEFINED.equals(securityMessageProfile);
  391.                 if(securityMessageProfilePrevedeTokenLocale) {
  392.                     addSecurity = existsSecurityFlusso;
  393.                 }
  394.                 
  395.                 boolean corniceSicurezza = ModIPropertiesUtils.isPropertySecurityMessageConCorniceSicurezza(aspc, nomePortType, azione);
  396.                 String patternCorniceSicurezza = null;
  397.                 String schemaCorniceSicurezza = null;
  398.                 if(corniceSicurezza) {
  399.                     patternCorniceSicurezza = ModIPropertiesUtils.readPropertySecurityMessageCorniceSicurezzaPattern(aspc, nomePortType, azione);
  400.                     if(patternCorniceSicurezza==null) {
  401.                         // backward compatibility
  402.                         patternCorniceSicurezza = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN_VALUE_OLD;
  403.                     }
  404.                     if(!ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN_VALUE_OLD.equals(patternCorniceSicurezza)) {
  405.                         schemaCorniceSicurezza = ModIPropertiesUtils.readPropertySecurityMessageCorniceSicurezzaSchema(aspc, nomePortType, azione);
  406.                     }
  407.                 }
  408.                 
  409.                 boolean bufferMessageReadOnly = this.modiProperties.isReadByPathBufferEnabled();

  411.                 boolean fruizione = isRichiesta;
  412.                 
  413.                 boolean addAudit = fruizione && corniceSicurezza && 
  414.                         patternCorniceSicurezza!=null && !ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN_VALUE_OLD.equals(patternCorniceSicurezza);
  415.                                 
  416.                 boolean keystoreKidMode = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0401.equals(securityMessageProfile)
  417.                         ||
  418.                         ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0402.equals(securityMessageProfile)
  419.                         ||
  420.                         !sorgenteLocale;
  421.                 
  422.                 Map<String, Object> dynamicMap = null;
  423.                 
  424.                 ModISecurityConfig securityConfig = null;
  425.                 ModISecurityConfig securityConfigAudit = null;
  426.                 ModIKeystoreConfig keystoreConfig = null;
  427.                 
  428.                 boolean keystoreDefinitoInFruizione = false;
  429.                 
  430.                 boolean keystoreDefinitoInTokenPolicy = false;
  431.                 String tokenPolicyKid = null;
  432.                 String tokenPolicyClientId = null;
  433.                 
  434.                 
  435.                 String headerTokenRest = null;
  436.                 String headerTokenRestIntegrity = null; // nel caso di Authorization insieme a Agid-JWT-Signature
  437.                 boolean integritaCustom = false;
  438.                 
  439.                 if(addSecurity || addAudit) {
  440.                 
  441.                     // dynamicMap
  442.                     Map<String, Object> dynamicMapRequest = null;
  443.                     if(RuoloMessaggio.RISPOSTA.equals(ruoloMessaggio)) {
  444.                         dynamicMapRequest = ModIUtilities.removeDynamicMapRequest(context);
  445.                     }
  446.                     if(dynamicMapRequest!=null) {
  447.                         dynamicMap = DynamicUtils.buildDynamicMapResponse(msg, context, busta, this.log, bufferMessageReadOnly, dynamicMapRequest);
  448.                     }
  449.                     else {
  450.                         dynamicMap = DynamicUtils.buildDynamicMap(msg, context, busta, this.log, bufferMessageReadOnly);
  451.                         ModIUtilities.saveDynamicMapRequest(context, dynamicMap);
  452.                     }
  453.                     
  454.                     // header
  455.                     Boolean multipleHeaderAuthorizationConfig = null;
  456.                     if(rest) {
  457.                         headerTokenRest = ModIPropertiesUtils.readPropertySecurityMessageHeader(aspc, nomePortType, azione, isRichiesta, filterPDND);
  458.                         if(headerTokenRest.contains(" ")) {
  459.                             String [] tmp = headerTokenRest.split(" ");
  460.                             if(tmp!=null && tmp.length==2 && tmp[0]!=null && tmp[1]!=null) {
  461.                                 headerTokenRest=tmp[0];
  462.                                 headerTokenRestIntegrity=tmp[1];
  463.                                 multipleHeaderAuthorizationConfig = true;
  464.                             }
  465.                         }
  466.                         integritaCustom = ModIPropertiesUtils.isPropertySecurityMessageHeaderCustom(aspc, nomePortType, azione, isRichiesta);
  467.                         /**
  468.                          * Lo registro nella busta solamente se lo aggiungo davvero dentro il metodo ModIImbustamentoRest
  469.                          * 
  470.                          * if(integritaCustom) {
  471.                             String hdrCustom = headerTokenRest;
  472.                             if(multipleHeaderAuthorizationConfig!=null && multipleHeaderAuthorizationConfig && headerTokenRestIntegrity!=null) {
  473.                                 hdrCustom = headerTokenRestIntegrity;
  474.                             }
  475.                             busta.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_CUSTOM_HEADER,hdrCustom);
  476.                         }*/
  477.                     }
  478.                     
  479.                     // modalita Keystore
  480.                     KeystoreParams tokenPolicyKeystore = null;
  481.                     if(isRichiesta) {
  482.                         
  483.                         keystoreDefinitoInFruizione = ModIKeystoreConfig.isKeystoreDefinitoInFruizione(idSoggettoMittente, asps);
  484.                         if(!keystoreDefinitoInFruizione) {
  485.                             keystoreDefinitoInTokenPolicy = ModIKeystoreConfig.isKeystoreDefinitoInTokenPolicy(idSoggettoMittente, asps);
  486.                         }
  487.                         
  488.                         StringBuilder sbRequired = new StringBuilder();
  489.                         if(keystoreDefinitoInTokenPolicy) {
  490.                             PolicyNegoziazioneToken pnt = ImbustamentoUtils.readPolicyNegoziazioneToken(this.log, state, idSoggettoMittente, idServizio, azione, requestInfo, sbRequired);
  491.                             if(pnt!=null) {
  492.                                 tokenPolicyKeystore = ImbustamentoUtils.readKeystoreParams(this.log, pnt, sbRequired);
  493.                                 if(sbRequired.length()<=0) {
  494.                                     tokenPolicyClientId = ImbustamentoUtils.readClientId(this.log, pnt, sbRequired);
  495.                                 }
  496.                                 if(sbRequired.length()<=0) {
  497.                                     tokenPolicyKid = ImbustamentoUtils.readKID(this.log, pnt, tokenPolicyClientId, tokenPolicyKeystore, sbRequired);
  498.                                 }
  499.                                 if(sbRequired.length()>0) {
  500.                                     tokenPolicyKeystore=null; // almeno dopo segnalo l'errore registrato in sbRequired
  501.                                 }
  502.                             }
  503.                         }
  504.                         
  505.                         boolean erroreTP=false;
  506.                         boolean erroreSA=false;
  507.                         if(keystoreDefinitoInTokenPolicy) {
  508.                             if(tokenPolicyKeystore==null) {
  509.                                 erroreTP= true;
  510.                             }
  511.                         }
  512.                         else if((!keystoreDefinitoInFruizione) && sa==null) {
  513.                             erroreSA=true;
  514.                         }
  515.                             
  516.                         if(erroreTP || erroreSA) {
  517.                             boolean auditMsg = addAudit && patternCorniceSicurezza!=null && StringUtils.isNotEmpty(patternCorniceSicurezza);
  518.                             StringBuilder sb = new StringBuilder("'");
  519.                             if(securityMessageProfile!=null && StringUtils.isNotEmpty(securityMessageProfile)) {
  520.                                 sb.append(securityMessageProfile);
  521.                                 if(auditMsg) {
  522.                                     sb.append("' + '").append(patternCorniceSicurezza);
  523.                                 }
  524.                             }
  525.                             else if(auditMsg) {
  526.                                 sb.append(patternCorniceSicurezza);
  527.                             }
  528.                             else {
  529.                                 sb.append("-");
  530.                             }
  531.                             sb.append("'");
  532.                             
  533.                             String descrizioneErrore = erroreTP ? sbRequired.toString() : "l'identificazione di un applicativo";
  534.                             
  535.                             ProtocolException pe = new ProtocolException("Il profilo di sicurezza richiesto "+sb.toString()+" richiede "+descrizioneErrore);
  536.                             pe.setInteroperabilityError(true);
  537.                             throw pe;
  538.                         }
  539.                     }
  540.                     
  541.                     // security config
  542.                     
  543.                     if(addAudit) {
  544.                         securityConfigAudit = new ModISecurityConfig(msg, context, protocolFactory, state, requestInfo, 
  545.                                 idSoggettoMittente, asps, sa, 
  546.                                 rest, fruizione, isRichiesta, 
  547.                                 patternCorniceSicurezza, schemaCorniceSicurezza,
  548.                                 busta, bustaRichiesta, 
  549.                                 multipleHeaderAuthorizationConfig,
  550.                                 keystoreDefinitoInFruizione, 
  551.                                 keystoreDefinitoInTokenPolicy, tokenPolicyKid, tokenPolicyClientId,
  552.                                 keystoreKidMode,
  553.                                 addSecurity, addAudit);
  554.                     }
  555.                     
  556.                     boolean keystoreKidModeSecurityToken = keystoreKidMode;
  557.                     if(rest && headerTokenRestIntegrity==null &&
  558.                         // un solo header
  559.                         (
  560.                                 ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0301.equals(securityMessageProfile)
  561.                                 ||
  562.                                 ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0302.equals(securityMessageProfile)
  563.                         ) 
  564.                     ){
  565.                         keystoreKidModeSecurityToken = false;
  566.                     }
  567.                     
  568.                     securityConfig = new ModISecurityConfig(msg, context, protocolFactory, state, requestInfo, 
  569.                             idSoggettoMittente, asps, sa, 
  570.                             rest, fruizione, isRichiesta, 
  571.                             patternCorniceSicurezza, schemaCorniceSicurezza,
  572.                             busta, bustaRichiesta, 
  573.                             multipleHeaderAuthorizationConfig,
  574.                             keystoreDefinitoInFruizione, 
  575.                             keystoreDefinitoInTokenPolicy, tokenPolicyKid, tokenPolicyClientId,
  576.                             keystoreKidModeSecurityToken,
  577.                             addSecurity, addAudit);
  578.                     
  579.                     // keystore
  580.                     
  581.                     if(isRichiesta) {
  582.                     
  583.                         if(keystoreDefinitoInFruizione) {
  584.                             keystoreConfig = new ModIKeystoreConfig(fruizione, idSoggettoMittente, asps, securityMessageProfile);
  585.                         }
  586.                         else if(keystoreDefinitoInTokenPolicy) {
  587.                             keystoreConfig = new ModIKeystoreConfig(tokenPolicyKeystore);
  588.                         }
  589.                         else {
  590.                             keystoreConfig = new ModIKeystoreConfig(sa, securityMessageProfile);
  591.                         }
  592.                         
  593.                     }
  594.                     else {
  595.                         
  596.                         keystoreConfig = new ModIKeystoreConfig(fruizione, idSoggettoMittente, asps, securityMessageProfile);
  597.                         
  598.                     }
  599.                 }
  600.                                 
  601.                 String purposeId = null;
  602.                 if(addSecurity || addAudit) {
  603.                     purposeId =  ModIPropertiesUtils.readPurposeId(configIntegrationReader, asps, idSoggettoMittente, azione);
  604.                 }
  605.                 
  606.                 long now = DateManager.getTimeMillis();
  607.                 
  608.                 
  609.                 // security (ID_AUTH e INTEGRITY)
  610.                 if(addSecurity) {
  611.                                                                         
  612.                     boolean includiRequestDigest = ModIPropertiesUtils.isPropertySecurityMessageIncludiRequestDigest(aspc, nomePortType, azione);
  613.                     
  614.                     boolean signAttachments = false;
  615.                     if(!rest) {
  616.                         signAttachments = ModIPropertiesUtils.isAttachmentsSignature(aspc, nomePortType, azione, isRichiesta, msg);
  617.                     }
  618.                         
  619.                     if(rest) {
  620.                         
  621.                         // Integrity verrà generato solo se:
  622.                         // Nel caso di 2 header da generare localmente, quello integrity viene prodotto solo se c'è un payload o uno degli header indicati da firmare.
  623.                         // Nel caso di 1 solo header da generare localmente, l'integrity, e l'authorization prodotto tramite token policy lo stesso verrà generato solo se c'è un payload o uno degli header indicati da firmare.
  624.                         boolean addIntegrity = false;
  625.                         boolean signedHeaders = false;
  626.                         if(securityConfig.getHttpHeaders()!=null && !securityConfig.getHttpHeaders().isEmpty()) {
  627.                             Map<String, List<String>> mapForceTransportHeaders = msg.getForceTransportHeaders();
  628.                             for (String httpHeader : securityConfig.getHttpHeaders()) {
  629.                                 if(!httpHeader.equalsIgnoreCase(HttpConstants.DIGEST)) {
  630.                                     List<String> values = ModIImbustamentoRest.getHeaderValues(ruoloMessaggio, msg, mapForceTransportHeaders, httpHeader);
  631.                                     if(values!=null && !values.isEmpty()) {
  632.                                         signedHeaders = true;
  633.                                         break;
  634.                                     }
  635.                                 }
  636.                             }
  637.                         }
  638.                         if(msg.castAsRest().hasContent() || signedHeaders) {
  639.                             addIntegrity = true;
  640.                         }
  641.                         else if(integritaCustom) {
  642.                             addIntegrity = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_HEADER_CUSTOM_MODE_VALUE_ALWAYS.equals(ModIPropertiesUtils.getPropertySecurityMessageHeaderCustomMode(aspc, nomePortType, azione, isRichiesta));
  643.                         }
  644.                         
  645.                         
  646.                         if(headerTokenRestIntegrity==null) {
  647.                             
  648.                             // Nel caso di 1 solo header da generare localmente, l'integrity, e l'authorization prodotto tramite token policy lo stesso verrà generato solo se c'è un payload o uno degli header indicati da firmare.
  649.                             if(sorgenteLocale || addIntegrity) {
  650.                             
  651.                                 String prefixMsgDiag = null;
  652.                                 if(HttpConstants.AUTHORIZATION.equalsIgnoreCase(headerTokenRest)) {
  653.                                     prefixMsgDiag = DIAGNOSTIC_ADD_TOKEN_ID_AUTH;
  654.                                 }
  655.                                 else {
  656.                                     prefixMsgDiag = DIAGNOSTIC_ADD_TOKEN_INTEGRITY;
  657.                                 }
  658.                                 try {
  659.                                     msgDiag.logPersonalizzato(prefixMsgDiag+tipoDiagnostico+DIAGNOSTIC_IN_CORSO);
  660.                                 
  661.                                     ModIJWTToken modiToken = imbustamentoRest.addToken(msg, isRichiesta, context, keystoreConfig, securityConfig, busta, 
  662.                                             securityMessageProfile, false, headerTokenRest, 
  663.                                             corniceSicurezza, patternCorniceSicurezza, 
  664.                                             null, // devo fornirlo solo durante la generazione dell'Audit Token 
  665.                                             ruoloMessaggio, includiRequestDigest,
  666.                                             now, busta.getID(), ModIHeaderType.SINGLE, integritaCustom,
  667.                                             dynamicMap, requestInfo,
  668.                                             purposeId, sicurezzaRidefinitaOperazione);
  669.                                     protocolMessage.setBustaRawContent(new ModIBustaRawContent(headerTokenRest, modiToken.getToken()));
  670.                                     
  671.                                     CostantiPdD.addKeywordInCache(msgDiag, modiToken.isInCache(), context, CostantiPdD.KEY_INFO_IN_CACHE_FUNZIONE_MODI_TOKEN_AUTHORIZATION); 
  672.                                     msgDiag.logPersonalizzato(prefixMsgDiag+tipoDiagnostico+DIAGNOSTIC_COMPLETATA);
  673.                                 }
  674.                                 catch(ProtocolException pe) {
  675.                                     msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, pe.getMessage());
  676.                                     msgDiag.logPersonalizzato(prefixMsgDiag+tipoDiagnostico+DIAGNOSTIC_FALLITA);
  677.                                     throw pe;
  678.                                 }
  679.                             }
  680.                             
  681.                         }
  682.                         else {
  683.                             
  684.                             String jtiAuthorization = busta.getID();
  685.                             String jtiIntegrity = busta.getID();
  686.                             if(!securityConfig.isMultipleHeaderUseSameJti()) {
  687.                                 if(securityConfig.isMultipleHeaderUseJtiAuthorizationAsIdMessaggio()) {
  688.                                     jtiIntegrity = newUniqueIdentifier();
  689.                                 }else {
  690.                                     jtiAuthorization = newUniqueIdentifier();
  691.                                 }
  692.                             }
  693.                             
  694.                             // Authorization
  695.                             String securityMessageProfileAuthorization = null;
  696.                             if(ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0301.equals(securityMessageProfile)
  697.                                     ||
  698.                                     ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0401.equals(securityMessageProfile)) {
  699.                                 securityMessageProfileAuthorization = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM01; 
  700.                             }
  701.                             else {
  702.                                 securityMessageProfileAuthorization = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM02; 
  703.                             }
  704.                             
  705.                             boolean useKIDforIdAUTH = false; // normalmente il token authorization sarà PDND, se cmq è locale lo genero uguale per il kid
  706.                             if(ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0401.equals(securityMessageProfile)
  707.                                     ||
  708.                                     ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0402.equals(securityMessageProfile)) {
  709.                                 useKIDforIdAUTH = true;
  710.                             }

  712.                             ModIJWTToken modiTokenAuthorization = null;
  713.                             try {
  714.                                 msgDiag.logPersonalizzato(DIAGNOSTIC_ADD_TOKEN_ID_AUTH+tipoDiagnostico+DIAGNOSTIC_IN_CORSO);
  715.                             
  716.                                 modiTokenAuthorization = imbustamentoRest.addToken(msg, isRichiesta, context, keystoreConfig, securityConfig, busta, 
  717.                                         securityMessageProfileAuthorization, useKIDforIdAUTH, headerTokenRest, 
  718.                                         corniceSicurezza, patternCorniceSicurezza, 
  719.                                         null, // devo fornirlo solo durante la generazione dell'Audit Token 
  720.                                         ruoloMessaggio, includiRequestDigest,
  721.                                         now, jtiAuthorization, ModIHeaderType.BOTH_AUTH, integritaCustom,
  722.                                         dynamicMap, requestInfo,
  723.                                         purposeId, sicurezzaRidefinitaOperazione);
  724.                                 
  725.                                 CostantiPdD.addKeywordInCache(msgDiag, modiTokenAuthorization.isInCache(), context, CostantiPdD.KEY_INFO_IN_CACHE_FUNZIONE_MODI_TOKEN_AUTHORIZATION); 
  726.                                 msgDiag.logPersonalizzato(DIAGNOSTIC_ADD_TOKEN_ID_AUTH+tipoDiagnostico+DIAGNOSTIC_COMPLETATA);
  727.                             }
  728.                             catch(ProtocolException pe) {
  729.                                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, pe.getMessage());
  730.                                 msgDiag.logPersonalizzato(DIAGNOSTIC_ADD_TOKEN_ID_AUTH+tipoDiagnostico+DIAGNOSTIC_FALLITA);
  731.                                 throw pe;
  732.                             }
  733.                             
  734.                             // Integrity
  735.                             // !! Nel caso di 2 header, quello integrity viene prodotto solo se c'è un payload o uno degli header indicati da firmare.
  736.                             ModIJWTToken modiTokenIntegrity = null;
  737.                             if(addIntegrity) {
  738.                                 try {
  739.                                     msgDiag.logPersonalizzato(DIAGNOSTIC_ADD_TOKEN_INTEGRITY+tipoDiagnostico+DIAGNOSTIC_IN_CORSO);
  740.                                     
  741.                                     boolean keystoreKidModeIntegrity = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0401.equals(securityMessageProfile)
  742.                                             ||
  743.                                             ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0402.equals(securityMessageProfile);                                  
  744.                                     ModISecurityConfig securityConfigIntegrity = new ModISecurityConfig(msg, context, protocolFactory, state, requestInfo,  
  745.                                             idSoggettoMittente, asps, sa, 
  746.                                             rest, fruizione, isRichiesta, 
  747.                                             patternCorniceSicurezza, schemaCorniceSicurezza,
  748.                                             busta, bustaRichiesta, 
  749.                                             false,
  750.                                             keystoreDefinitoInFruizione, 
  751.                                             keystoreDefinitoInTokenPolicy, tokenPolicyKid, tokenPolicyClientId,
  752.                                             keystoreKidModeIntegrity,
  753.                                             addSecurity, addAudit);
  754.                                     modiTokenIntegrity = imbustamentoRest.addToken(msg, isRichiesta, context, keystoreConfig, securityConfigIntegrity, busta, 
  755.                                             securityMessageProfile, false, headerTokenRestIntegrity, 
  756.                                             corniceSicurezza, patternCorniceSicurezza, 
  757.                                             null, // devo fornirlo solo durante la generazione dell'Audit Token 
  758.                                             ruoloMessaggio, includiRequestDigest,
  759.                                             now, jtiIntegrity, ModIHeaderType.BOTH_INTEGRITY, integritaCustom,
  760.                                             dynamicMap, requestInfo,
  761.                                             purposeId, sicurezzaRidefinitaOperazione);
  762.                                     
  763.                                     // l'integrity non sarà mai in cache, ma il diagnostico e' condiviso
  764.                                     CostantiPdD.addKeywordInCache(msgDiag, modiTokenIntegrity.isInCache(), context, CostantiPdD.KEY_INFO_IN_CACHE_FUNZIONE_MODI_TOKEN_INTEGRITY); 
  765.                                     msgDiag.logPersonalizzato(DIAGNOSTIC_ADD_TOKEN_INTEGRITY+tipoDiagnostico+DIAGNOSTIC_COMPLETATA);
  766.                                 }
  767.                                 catch(ProtocolException pe) {
  768.                                     msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, pe.getMessage());
  769.                                     msgDiag.logPersonalizzato(DIAGNOSTIC_ADD_TOKEN_INTEGRITY+tipoDiagnostico+DIAGNOSTIC_FALLITA);
  770.                                     throw pe;
  771.                                 }
  772.                             }
  773.                             
  774.                             if(modiTokenIntegrity!=null) {
  775.                                 protocolMessage.setBustaRawContent(new ModIBustaRawContent(modiTokenAuthorization.getToken(), headerTokenRestIntegrity, modiTokenIntegrity.getToken()));
  776.                             }
  777.                             else {
  778.                                 protocolMessage.setBustaRawContent(new ModIBustaRawContent(headerTokenRest, modiTokenAuthorization.getToken()));
  779.                             }
  780.                                                         
  781.                         }
  782.                     }
  783.                     else {
  784.                         // soap
  785.                         boolean integritaX509 = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0301.equals(securityMessageProfile) || 
  786.                                 ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0302.equals(securityMessageProfile);
  787.                         boolean integritaKid = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0401.equals(securityMessageProfile) || 
  788.                                 ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0402.equals(securityMessageProfile);
  789.                         boolean integrita = integritaX509 || integritaKid;
  790.                         
  791.                         String prefixMsgDiag = null;
  792.                         MapKey<String> mapKey = null;
  793.                         if(integrita) {
  794.                             prefixMsgDiag = DIAGNOSTIC_ADD_TOKEN_INTEGRITY;
  795.                             mapKey = CostantiPdD.KEY_INFO_IN_CACHE_FUNZIONE_MODI_TOKEN_INTEGRITY;
  796.                         }
  797.                         else {
  798.                             prefixMsgDiag = DIAGNOSTIC_ADD_TOKEN_ID_AUTH;
  799.                             mapKey = CostantiPdD.KEY_INFO_IN_CACHE_FUNZIONE_MODI_TOKEN_AUTHORIZATION;
  800.                         }
  801.                         try {
  802.                             msgDiag.logPersonalizzato(prefixMsgDiag+tipoDiagnostico+DIAGNOSTIC_IN_CORSO);
  803.                             
  804.                             boolean corniceSicurezzaLegacySoap = corniceSicurezza && !addAudit;
  805.                             
  806.                             SOAPEnvelope env = imbustamentoSoap.addSecurity(msg, isRichiesta, context, keystoreConfig, securityConfig, busta, 
  807.                                     securityMessageProfile, corniceSicurezzaLegacySoap, ruoloMessaggio, includiRequestDigest, signAttachments,
  808.                                     dynamicMap, requestInfo);
  809.                             protocolMessage.setBustaRawContent(new ModIBustaRawContent(env));
  810.                             
  811.                             // il token SOAP non è mai in cache
  812.                             CostantiPdD.addKeywordInCache(msgDiag, false, context, mapKey);
  813.                             msgDiag.logPersonalizzato(prefixMsgDiag+tipoDiagnostico+DIAGNOSTIC_COMPLETATA);
  814.                         }
  815.                         catch(ProtocolException pe) {
  816.                             msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, pe.getMessage());
  817.                             msgDiag.logPersonalizzato(prefixMsgDiag+tipoDiagnostico+DIAGNOSTIC_FALLITA);
  818.                             throw pe;
  819.                         }
  820.                     }
  821.                     
  822.                 }
  823.                 
  824.                 // audit (ID_AUDIT)
  825.                 if(addAudit) {
  826.                     
  827.                     busta.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_AUDIT_PATTERN, 
  828.                             ModIPropertiesUtils.convertProfiloAuditToSDKValue(patternCorniceSicurezza));
  829.                     busta.addProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_AUDIT_SCHEMA, 
  830.                             ModIPropertiesUtils.convertSchemaAuditToSDKValue(schemaCorniceSicurezza, this.modiProperties));
  831.                     
  832.                     if(imbustamentoRest==null) {
  833.                         // audit su api soap
  834.                         imbustamentoRest = new ModIImbustamentoRest(this.log);
  835.                     }
  836.                     
  837.                     String securityMessageProfileAudit = null;
  838.                     if(ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0301.equals(securityMessageProfile)
  839.                             ||
  840.                             ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0401.equals(securityMessageProfile)) {
  841.                         securityMessageProfileAudit = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM01; 
  842.                     }
  843.                     else {
  844.                         securityMessageProfileAudit = ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM02; 
  845.                     }
  846.                                         
  847.                     boolean useKIDforAudit = false;
  848.                     if(ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0401.equals(securityMessageProfile)
  849.                             ||
  850.                             ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_VALUE_IDAM0402.equals(securityMessageProfile)
  851.                             ||
  852.                             !sorgenteLocale) {
  853.                         useKIDforAudit = true;
  854.                     }
  855.                     
  856.                     String headerTokenAudit = this.modiProperties.getSecurityTokenHeaderModIAudit();
  857.                     
  858.                     String jtiAudit = newUniqueIdentifier();
  859.                     
  860.                     try {
  861.                         msgDiag.logPersonalizzato("addTokenAudit.richiesta.inCorso");
  862.                     
  863.                         ModIJWTToken modiTokenAudit = imbustamentoRest.addToken(msg, isRichiesta, context, keystoreConfig, securityConfigAudit, busta, 
  864.                                 securityMessageProfileAudit, useKIDforAudit, headerTokenAudit, 
  865.                                 corniceSicurezza, patternCorniceSicurezza, schemaCorniceSicurezza,
  866.                                 ruoloMessaggio, false,
  867.                                 now, jtiAudit, ModIHeaderType.SINGLE, false,
  868.                                 dynamicMap, requestInfo,
  869.                                 purposeId, sicurezzaRidefinitaOperazione);
  870.                         if(protocolMessage.getBustaRawContent() instanceof ModIBustaRawContent) {
  871.                             ModIBustaRawContent raw = (ModIBustaRawContent) protocolMessage.getBustaRawContent();
  872.                             raw.getElement().setTokenAudit(headerTokenAudit, modiTokenAudit.getToken());
  873.                         }
  874.                         
  875.                         CostantiPdD.addKeywordInCache(msgDiag, modiTokenAudit.isInCache(), context, CostantiPdD.KEY_INFO_IN_CACHE_FUNZIONE_MODI_TOKEN_AUDIT); 
  876.                         msgDiag.logPersonalizzato("addTokenAudit.richiesta.completata");
  877.                     }
  878.                     catch(ProtocolException pe) {
  879.                         msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, pe.getMessage());
  880.                         msgDiag.logPersonalizzato("addTokenAudit.richiesta.fallita");
  881.                         throw pe;
  882.                     }
  883.                 }

  885.             }
  886.             
  887.             protocolMessage.setMessage(msg);
  888.             return protocolMessage;
  889.         
  890.         }
  891.         catch(ProtocolException pe) {
  892.             if(pe.isInteroperabilityError() &&
  893.                 context!=null) {
  894.                 context.addObject(Costanti.ERRORE_VALIDAZIONE_PROTOCOLLO, Costanti.ERRORE_TRUE);
  895.             }
  896.             throw pe;
  897.         }
  898.         catch(Exception e){
  899.             throw new ProtocolException(e.getMessage(),e);
  900.         }
  901.         
  902.     }
  903.     
  904.     private OpenSPCoop2Message computeSignalHubMessage(OpenSPCoop2Message msg, Context context, 
  905.             IProtocolFactory<?> protocolFactory, IState state) throws ProtocolException, UtilsException, DriverConfigurazioneException, IOException {
  906.         
  907.         // ottengo le informazioni inserite dall'handler
  908.         IDServizio idServizio = (IDServizio) context.get(ModICostanti.MODIPA_KEY_INFO_SIGNAL_HUB_SERVICE);
  909.         String objectId = (String) context.get(ModICostanti.MODIPA_KEY_INFO_SIGNAL_HUB_OBJECT_ID);
  910.         String objectType = (String) context.get(ModICostanti.MODIPA_KEY_INFO_SIGNAL_HUB_OBJECT_TYPE);
  911.         ModISignalHubOperation signalType = (ModISignalHubOperation) context.get(ModICostanti.MODIPA_KEY_INFO_SIGNAL_HUB_SIGNAL_TYPE);
  912.         String serviceId = (String) context.get(ModICostanti.MODIPA_KEY_INFO_SIGNAL_HUB_ESERVICE_ID);
  913.         
  914.         // configuro il generatore di numeri seriali
  915.         ConfigurazionePdD config = protocolFactory.getConfigurazionePdD();
  916.         IDSerialGenerator serialGenerator = new IDSerialGenerator(config.getLog(), state, config.getTipoDatabase());
  917.         
  918.         IDSerialGeneratorParameter serialGeneratorParameter = new IDSerialGeneratorParameter(protocolFactory.getProtocol());
  919.         serialGeneratorParameter.setSerializableTimeWaitMs(config.getAttesaAttivaJDBC());
  920.         serialGeneratorParameter.setSerializableNextIntervalTimeMs(config.getCheckIntervalJDBC());
  921.         serialGeneratorParameter.setTipo(IDSerialGeneratorType.NUMERIC);
  922.         serialGeneratorParameter.setWrap(true);
  923.         serialGeneratorParameter.setSize(256);
  924.         serialGeneratorParameter.setMaxValue(Long.MAX_VALUE);
  925.         serialGeneratorParameter.setInformazioneAssociataAlProgressivo(serviceId);
  926.         
  927.         // se mi trovo in condizione di seedupdate il signalId sara gia stato creato e inserito come objectId da govway
  928.         Long signalId;
  929.         if (signalType.equals(ModISignalHubOperation.SEEDUPDATE)) {
  930.             signalId = Long.valueOf(objectId);
  931.             
  932.             objectId = "-";
  933.             objectType = "-";
  934.         } else {
  935.             
  936.             // per le operazione UPDATE, CREATE, DELETE ottengo i dati per produrre il digest dell'id
  937.             DigestServiceParams param = obtainDigestServiceParam(context, idServizio, serialGenerator, serialGeneratorParameter);
  938.             
  939.             // configuro il generatore di digest
  940.             DigestConfig digestConfig = new DigestConfig();
  941.             digestConfig.setDigestType(param.getDigestAlgorithm());
  942.             digestConfig.setSaltLength(param.getSeed().length);
  943.             digestConfig.setHashComposition(this.modiProperties.getSignalHubHashCompose());
  944.             digestConfig.setBase64Encode(true);
  945.             
  946.             IDigest digestGenerator = DigestFactory.getDigest(this.log, digestConfig);
  947.             
  948.             // produco il digest e il numero seriale del segnale
  949.             objectId = new String(digestGenerator.digest(objectId.getBytes(), param.getSeed()));
  950.             signalId = Long.valueOf(serialGenerator.buildID(serialGeneratorParameter));
  951.         }
  952.         
  953.         // serializzo le informazioni prodotte in json
  954.         JSONUtils jsonUtils = JSONUtils.getInstance();
  955.         ObjectNode root = jsonUtils.newObjectNode();
  956.         root.put(ModICostanti.MODIPA_SIGNAL_HUB_ID_SIGNAL_ID, signalId);
  957.         root.put(ModICostanti.MODIPA_SIGNAL_HUB_ID_OBJECT_TYPE, objectType);
  958.         root.put(ModICostanti.MODIPA_SIGNAL_HUB_ID_OBJECT_ID, objectId);
  959.         root.put(ModICostanti.MODIPA_SIGNAL_HUB_ID_ESERVICE_ID, serviceId);
  960.         root.put(ModICostanti.MODIPA_SIGNAL_HUB_ID_SIGNAL_TYPE, signalType.toString());
  961.         
  962.         
  963.         // altero il messaggio govway in modo tale di restituire al backend il nuovo messaggio
  964.         TransportRequestContext transportRequestContext = msg.getTransportRequestContext();
  965.         String protocolName = msg.getProtocolName();
  966.         String transactionId = msg.getTransactionId();
  967.         
  968.         msg = OpenSPCoop2MessageFactory.getDefaultMessageFactory().createMessage(
  969.                 msg.getMessageType(), 
  970.                 msg.getMessageRole(), 
  971.                 HttpConstants.CONTENT_TYPE_JSON,
  972.                 jsonUtils.toByteArray(root)).getMessage();
  973.         
  974.         msg.setTransportRequestContext(transportRequestContext);
  975.         msg.setProtocolName(protocolName);
  976.         msg.setTransactionId(transactionId);
  977.         
  978.         return msg;
  979.     }
  980.     
  981.     private static final String ERROR_MESSAGE_SEED_NOT_UPDATED = "seed update non riuscito";
  982.     private DigestServiceParams obtainDigestServiceParam(Context context, IDServizio idServizio, IDSerialGenerator serialGenerator, IDSerialGeneratorParameter serialGeneratorParameter) throws ProtocolException, UtilsException, DriverConfigurazioneException, IOException {     
  983.         
  984.         // ottengo il driver di configurazione
  985.         Object db = ConfigurazionePdDReader.getDriverConfigurazionePdD();
  986.         if (!(db instanceof DriverConfigurazioneDB))
  987.             throw new ProtocolException("driver db non trovato");
  988.         
  989.         // ottengo il driver per le informazioni diagnostiche
  990.         DigestServiceParamsDriver driver = new DigestServiceParamsDriver((DriverConfigurazioneDB) db);
  991.         DigestServiceParams param = driver.getValidEntry(idServizio);
  992.         
  993.         // non esiste informazioni crittografiche valide devo rigenerarle
  994.         if (param == null) {
  995.             RequestInfo reqInfo = (RequestInfo) context.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  996.             
  997.             driver.acquireLock(reqInfo.getIdTransazione());
  998.             try (MockServletInputStream is = new MockServletInputStream()) {
  999.                 
  1000.                 // riprovo a vedere se esistono informaizoni crittografiche valide prodotte da un altro thread nel frattempo
  1001.                 param = driver.getValidEntry(idServizio);
  1002.                 if (param != null)
  1003.                     return param;
  1004.                 
  1005.                 // genero nuove informazioni crittografiche
  1006.                 List<ProtocolProperty> eServiceProperties = SignalHubUtils.obtainSignalHubProtocolProperty(context);
  1007.                 
  1008.                 String seedSignalId = serialGenerator.buildID(serialGeneratorParameter);
  1009.                 param = SignalHubUtils.generateDigestServiceParams(idServizio, eServiceProperties, Long.valueOf(seedSignalId));

  1011.                 String eServiceId = ProtocolPropertiesUtils.getRequiredStringValuePropertyRegistry(eServiceProperties, ModICostanti.MODIPA_API_IMPL_INFO_ID_ESERVICE_ID);
  1012.                 
  1013.                 
  1014.                 // creo una richiesta e risposta servlet mock per inviare un segnale di SEEDUPDATE alla stessa porta delegata con le stesse credenziali 
  1015.                 MockHttpServletRequest req = new MockHttpServletRequest(reqInfo.getProtocolContext().getHttpServletRequest());
  1016.                 MockHttpServletResponse res = new MockHttpServletResponse();
  1017.                 
  1018.                 // i segnali di SEEDUPDATE devono essere inserite negli header di default
  1019.                 req.setInputStream(is);
  1020.                 req.setHeader("GovWay-Signal-Type", List.of(ModISignalHubOperation.SEEDUPDATE.toString()));
  1021.                 req.setHeader("GovWay-Signal-ObjectId", List.of(seedSignalId));
  1022.                 req.setHeader("GovWay-Signal-ObjectType", List.of("seed"));
  1023.                 req.setHeader("GovWay-Signal-ServiceId", List.of(eServiceId));
  1024.                 req.setHeader("Content-Length", List.of("0"));
  1025.                 req.setHeader("Content-Type", null);
  1026.                 
  1027.                 // rimuove la transazione corrente dal contesto in quanto verra eseguita la transazione per il SEEDUPDATE
  1028.                 Transaction transaction = TransactionContext.removeTransaction(reqInfo.getIdTransazione());
  1029.                 
  1030.                 try {
  1031.                     req.getRequestDispatcher(req.getPathInfo()).forward(req, res);
  1032.                 } catch (Exception e) {
  1033.                     throw newSeedUpdateException(e);
  1034.                 } finally {
  1035.                     try {
  1036.                         TransactionContext.setTransactionThreadLocal(reqInfo.getIdTransazione(), transaction);
  1037.                     } catch (TransactionNotExistsException e) {
  1038.                         // ignore should never happen
  1039.                     }
  1040.                 }
  1041.                 
  1042.                 // controllo che il backend abbia ritornato una risposta positiva di creazione del seme
  1043.                 try {
  1044.                     if (res.getStatus() != HttpServletResponse.SC_OK) {
  1045.                         throw newSeedUpdateException("returnCode:"+res.getStatus());
  1046.                     }
  1047.                     byte[] out = ((MockServletOutputStream)res.getOutputStream()).getByteArrayOutputStream().toByteArray();
  1048.                     
  1049.                     JSONUtils jsonUtils = JSONUtils.getInstance();
  1050.                     JsonNode node = jsonUtils.getAsNode(out);
  1051.                     if (node.get(ModICostanti.MODIPA_SIGNAL_HUB_ID_SIGNAL_ID).isNull())
  1052.                         throw newSeedUpdateException("signalId is null");
  1053.                 } catch (IOException e) {
  1054.                     throw newSeedUpdateException(e, "seed response invalid");
  1055.                 }
  1056.                 
  1057.                 // posso inserire le nuove informazioni crittografiche
  1058.                 driver.addNewEntry(param);
  1059.                 
  1060.             } finally {
  1061.                 driver.releaseLock();
  1062.             }
  1063.             
  1064.             // rimuovo le informazioni crittografiche vecchie
  1065.             driver.removeOldEntries(idServizio, this.modiProperties.getSignalHubDigestHistroy());
  1066.         }
  1067.         
  1068.         return param;
  1069.     }
  1070.     private ProtocolException newSeedUpdateException(Exception e) {
  1071.         return newSeedUpdateException(e, null);
  1072.     }
  1073.     private ProtocolException newSeedUpdateException(String posizione) {
  1074.         return newSeedUpdateException(null, posizione);
  1075.     }
  1076.     private ProtocolException newSeedUpdateException(Exception e, String posizione) {
  1077.         String msgError = posizione!=null ? " ("+posizione+")" : "";
  1078.         msgError = ERROR_MESSAGE_SEED_NOT_UPDATED + msgError;
  1079.         if(this.log!=null && e!=null) {
  1080.             this.log.error("{}: {}",msgError,e.getMessage(),e);
  1081.         }
  1082.         return new ProtocolException(msgError);
  1083.     }
  1084.     
  1085. }
Created with JaCoCo 0.8.8.202204050719