ConnettoreSignalHubPseudonymization.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.connettori;

  23. import java.io.ByteArrayInputStream;
  24. import java.util.ArrayList;
  25. import java.util.HashMap;
  26. import java.util.Iterator;
  27. import java.util.List;
  28. import java.util.Map;

  30. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  31. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  32. import org.openspcoop2.core.config.driver.db.DriverConfigurazioneDB;
  33. import org.openspcoop2.core.constants.CostantiConnettori;
  34. import org.openspcoop2.core.id.IDServizio;
  35. import org.openspcoop2.core.registry.ProtocolProperty;
  36. import org.openspcoop2.core.transazioni.constants.TipoMessaggio;
  37. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  38. import org.openspcoop2.message.OpenSPCoop2MessageParseResult;
  39. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  40. import org.openspcoop2.message.constants.Costanti;
  41. import org.openspcoop2.message.constants.MessageRole;
  42. import org.openspcoop2.message.constants.MessageType;
  43. import org.openspcoop2.message.soap.TunnelSoapUtils;
  44. import org.openspcoop2.pdd.config.ConfigurazionePdDReader;
  45. import org.openspcoop2.pdd.config.DigestServiceParams;
  46. import org.openspcoop2.pdd.config.DigestServiceParamsDriver;
  47. import org.openspcoop2.pdd.core.PdDContext;
  48. import org.openspcoop2.pdd.core.Utilities;
  49. import org.openspcoop2.pdd.core.connettori.ConnettoreBaseWithResponse;
  50. import org.openspcoop2.pdd.core.connettori.ConnettoreException;
  51. import org.openspcoop2.pdd.core.connettori.ConnettoreLogger;
  52. import org.openspcoop2.pdd.core.connettori.ConnettoreMsg;
  53. import org.openspcoop2.protocol.modipa.constants.ModICostanti;
  54. import org.openspcoop2.protocol.modipa.utils.SignalHubUtils;
  55. import org.openspcoop2.protocol.sdk.ProtocolException;
  56. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  57. import org.openspcoop2.utils.UtilsException;
  58. import org.openspcoop2.utils.date.DateManager;
  59. import org.openspcoop2.utils.io.DumpByteArrayOutputStream;
  60. import org.openspcoop2.utils.json.JSONUtils;
  61. import org.openspcoop2.utils.rest.problem.JsonSerializer;
  62. import org.openspcoop2.utils.rest.problem.ProblemRFC7807;
  63. import org.openspcoop2.utils.transport.TransportResponseContext;
  64. import org.openspcoop2.utils.transport.TransportUtils;
  65. import org.openspcoop2.utils.transport.http.HttpConstants;
  66. import org.openspcoop2.utils.transport.http.HttpUtilities;

  68. import com.fasterxml.jackson.databind.node.ObjectNode;


  71. /**
  72.  *
  73.  * @author Tommaso Burlon (tommaso.burlon@link.it)
  74.  * @author $Author$
  75.  * @version $Rev$, $Date$
  76.  */

  78. public class ConnettoreSignalHubPseudonymization extends ConnettoreBaseWithResponse {
  79.     
  80.     @Override
  81.     public String getProtocollo() {
  82.         return "http";
  83.     }
  84.     
  85.     public static final String LOCATION = "govway://signalHubPseudonymization";
  86.     
  87.     private DumpByteArrayOutputStream requestBout = null;

  89.     
  90.     private DigestServiceParams initCryptoInfo(DigestServiceParamsDriver driver, PdDContext context) throws UtilsException, DriverConfigurazioneException, ProtocolException {
  91.         RequestInfo reqInfo = (RequestInfo) context.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  92.         IDServizio idServizio = reqInfo.getIdServizio();
  93.         DigestServiceParams param = null;
  94.         
  95.         List<ProtocolProperty> protocolProperty = SignalHubUtils.obtainSignalHubProtocolProperty(context);
  96.         
  97.         // provo ad inizializzare il db
  98.         driver.acquireLock(reqInfo.getIdTransazione());
  99.         try {
  100.             
  101.             // se le informazioni crittografiche esistono gia le ritorno altrimenti le genero
  102.             param = driver.getLastEntry(idServizio);
  103.             if (param != null)
  104.                 return param;
  105.             
  106.             param = SignalHubUtils.generateDigestServiceParams(idServizio, protocolProperty, null);
  107.             driver.addNewEntry(param);
  108.         } finally {
  109.             driver.releaseLock();
  110.         }
  111.         
  112.         return param;
  113.     }
  114.     
  115.     private void retrieveCryptoInfo(PdDContext pddContext) throws UtilsException, DriverConfigurazioneException, ProtocolException, ConnettoreException {
  116.         
  117.         RequestInfo reqInfo = (RequestInfo) pddContext.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  118.         IDServizio idServizio = reqInfo.getIdServizio();
  119.         
  120.         // ottengo il driver di configurazione
  121.         Object db = ConfigurazionePdDReader.getDriverConfigurazionePdD();
  122.         if (!(db instanceof DriverConfigurazioneDB))
  123.             throw new UtilsException("driver trovato non di tipo db");
  124.         
  125.         
  126.         // cerco di ottenere l'id del segnale per fare una ricerca puntuale delle informazioni crittografiche
  127.         String signalIdRaw = reqInfo.getProtocolContext().getParameterFirstValue(ModICostanti.MODIPA_SIGNAL_HUB_ID_SIGNAL_ID);
  128.         DigestServiceParams param = null;
  129.         
  130.         try {
  131.             Long signalId = signalIdRaw != null ? Long.parseLong(signalIdRaw) : null;
  132.             DigestServiceParamsDriver driver = new DigestServiceParamsDriver((DriverConfigurazioneDB) db);
  133.             
  134.             // se signalId risulta uguale a null ritornero le informazioni critoogtafiche piu recenti
  135.             param = driver.getEntry(idServizio, signalId);
  136.             
  137.             // se non esistno informazioni crittografiche nel db lo inizializzo
  138.             if (param == null && signalId == null) {
  139.                 param = this.initCryptoInfo(driver, pddContext);
  140.             }
  141.             
  142.         } catch (NumberFormatException e) {
  143.             throw new ConnettoreException("signalId params non int64");
  144.         }
  145.         
  146.         
  147.         // se non ho trovato alcuna informazione crittografica ritorno 404
  148.         if (param == null) {
  149.             ProblemRFC7807 problemRFC7807 = new ProblemRFC7807();
  150.             problemRFC7807.setStatus(404);
  151.             problemRFC7807.setDetail("Informazioni di pseudoanonimizzazione non trovate");
  152.             problemRFC7807.setTitle("Not Found");
  153.             problemRFC7807.setType("https://httpstatuses.com/404");
  154.             
  155.             JsonSerializer jsonSerializer = new JsonSerializer();
  156.             this.isResponse = new ByteArrayInputStream(jsonSerializer.toByteArray(problemRFC7807));
  157.             this.tipoRisposta = HttpConstants.CONTENT_TYPE_JSON_PROBLEM_DETAILS_RFC_7807;
  158.             this.codice = 404;
  159.             return;
  160.         }

  162.         // serializzo il messsaggio
  163.         JSONUtils jsonUtils = JSONUtils.getInstance();
  164.         ObjectNode node = jsonUtils.newObjectNode();
  165.         node.put("seed", new String(param.getSeed()));
  166.         node.put("cryptoHashFunction", param.getDigestAlgorithm().toString());
  167.         
  168.         this.isResponse = new ByteArrayInputStream(jsonUtils.toByteArray(node));
  169.         this.tipoRisposta = HttpConstants.CONTENT_TYPE_JSON;
  170.         this.codice = 200;
  171.     }
  172.     
  173.     /* ********  METODI  ******** */

  175.     @Override
  176.     protected boolean initializePreSend(ResponseCachingConfigurazione responseCachingConfig, ConnettoreMsg request) {
  177.         return this.initialize(request, false, responseCachingConfig);
  178.     }
  179.     
  180.     
  181.     @Override
  182.     protected boolean send(ConnettoreMsg request) {
  183.         PdDContext pddContext = request.getOutRequestContext().getPddContext();
  184.                 
  185.         this.codice = 200;
  186.         
  187.         try{
  188.             
  189.             // Tipologia di servizio
  190.             MessageType requestMessageType = this.requestMsg.getMessageType();
  191.             OpenSPCoop2SoapMessage soapMessageRequest = null;
  192.             if(this.debug)
  193.                 this.logger.debug("Tipologia Servizio: "+this.requestMsg.getServiceBinding());
  194.             if(this.isSoap){
  195.                 soapMessageRequest = this.requestMsg.castAsSoap();
  196.             }
  197.             
  198.             
  199.             // Collezione header di trasporto per dump
  200.             Map<String, List<String>> propertiesTrasportoDebug = null;
  201.             if(this.isDumpBinarioRichiesta()) {
  202.                 propertiesTrasportoDebug = new HashMap<>();
  203.             }
  204.             
  205.             
  206.             // Impostazione Content-Type
  207.             String contentTypeRichiesta = null;
  208.             if(this.debug)
  209.                 this.logger.debug("Impostazione content type...");
  210.             if(this.isSoap){
  211.                 if(this.sbustamentoSoap && soapMessageRequest.countAttachments()>0 && TunnelSoapUtils.isTunnelOpenSPCoopSoap(soapMessageRequest)){
  212.                     contentTypeRichiesta = TunnelSoapUtils.getContentTypeTunnelOpenSPCoopSoap(soapMessageRequest.getSOAPBody());
  213.                 }else{
  214.                     contentTypeRichiesta = this.requestMsg.getContentType();
  215.                 }
  216.                 if(contentTypeRichiesta==null){
  217.                     throw new ConnettoreException("Content-Type del messaggio da spedire non definito");
  218.                 }
  219.             }
  220.             else{
  221.                 contentTypeRichiesta = this.requestMsg.getContentType();
  222.                 // Content-Type non obbligatorio in REST
  223.             }
  224.             if(this.debug)
  225.                 this.logger.info("Impostazione Content-Type ["+contentTypeRichiesta+"]",false);
  226.             if(contentTypeRichiesta!=null){
  227.                 setRequestHeader(HttpConstants.CONTENT_TYPE, contentTypeRichiesta, this.logger, propertiesTrasportoDebug);
  228.             }
  229.             
  230.             
  231.             
  232.             // Impostazione timeout
  233.             if(this.debug)
  234.                 this.logger.debug("Impostazione timeout...");
  235.             int readConnectionTimeout = -1;
  236.             boolean readConnectionTimeoutConfigurazioneGlobale = true;
  237.             if(this.properties.get(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT)!=null){
  238.                 try{
  239.                     readConnectionTimeout = Integer.parseInt(this.properties.get(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT));
  240.                     readConnectionTimeoutConfigurazioneGlobale = this.properties.containsKey(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT_GLOBALE);
  241.                 }catch(Exception e){
  242.                     this.logger.error("Parametro "+CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT+" errato",e);
  243.                 }
  244.             }
  245.             if(readConnectionTimeout==-1){
  246.                 readConnectionTimeout = HttpUtilities.HTTP_READ_CONNECTION_TIMEOUT;
  247.             }
  248.             if(this.debug)
  249.                 this.logger.info("Impostazione read timeout ["+readConnectionTimeout+"]",false);
  250.             
  251.             
  252.             // Impostazione Proprieta del trasporto
  253.             if(this.debug)
  254.                 this.logger.debug("Impostazione header di trasporto...");
  255.             this.forwardHttpRequestHeader();
  256.             if(this.propertiesTrasporto != null){
  257.                 Iterator<String> keys = this.propertiesTrasporto.keySet().iterator();
  258.                 while (keys.hasNext()) {
  259.                     String key = keys.next();
  260.                     List<String> values = this.propertiesTrasporto.get(key);
  261.                     if(this.debug && values!=null && !values.isEmpty()) {
  262.                             for (String value : values) {
  263.                                 this.logger.info("Set proprietà trasporto ["+key+"]=["+value+"]",false);
  264.                             }
  265.                         }
  266.                     setRequestHeader(key, values, this.logger, propertiesTrasportoDebug);
  267.                 }
  268.             }
  269.             
  270.             
  271.             
  272.             // Aggiunga del SoapAction Header in caso di richiesta SOAP
  273.             // spostato sotto il forwardHeader per consentire alle trasformazioni di modificarla
  274.             if(this.isSoap && !this.sbustamentoSoap){
  275.                 if(this.debug)
  276.                     this.logger.debug("Impostazione soap action...");
  277.                 boolean existsTransportProperties = false;
  278.                 if(TransportUtils.containsKey(this.propertiesTrasporto, Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION)){
  279.                     this.soapAction = TransportUtils.getFirstValue(this.propertiesTrasporto, Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION);
  280.                     existsTransportProperties = (this.soapAction!=null);
  281.                 }
  282.                 if(!existsTransportProperties) {
  283.                     this.soapAction = soapMessageRequest.getSoapAction();
  284.                 }
  285.                 if(this.soapAction==null){
  286.                     this.soapAction="\"OpenSPCoop\"";
  287.                 }
  288.                 if(MessageType.SOAP_11.equals(this.requestMsg.getMessageType()) && !existsTransportProperties){
  289.                     // NOTA non quotare la soap action, per mantenere la trasparenza della PdD
  290.                     setRequestHeader(Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION,this.soapAction, propertiesTrasportoDebug);
  291.                 }
  292.                 if(this.debug)
  293.                     this.logger.info("SOAP Action inviata ["+this.soapAction+"]",false);
  294.             }
  295.             
  296.             
  297.             
  298.             // SIMULAZIONE WRITE_TO
  299.             boolean consumeRequestMessage = true;
  300.             if(this.debug)
  301.                 this.logger.debug("Serializzazione (consume-request-message:"+consumeRequestMessage+")...");
  302.             if(this.isDumpBinarioRichiesta()) {
  303.                 this.requestBout = new DumpByteArrayOutputStream(this.dumpBinario_soglia, this.dumpBinario_repositoryFile, this.idTransazione, 
  304.                         "NullEcho-"+TipoMessaggio.RICHIESTA_USCITA_DUMP_BINARIO.getValue());
  305.                 
  306.                 this.emitDiagnosticStartDumpBinarioRichiestaUscita();
  307.                 
  308.                 if(this.isSoap && this.sbustamentoSoap){
  309.                     this.logger.debug("Sbustamento...");
  310.                     TunnelSoapUtils.sbustamentoMessaggio(soapMessageRequest,this.requestBout);
  311.                 }else{
  312.                     this.requestMsg.writeTo(this.requestBout, consumeRequestMessage);
  313.                 }
  314.                 this.requestBout.flush();
  315.                 this.requestBout.close();
  316.                                     
  317.                 this.dataRichiestaInoltrata = DateManager.getDate();
  318.                 
  319.                 this.dumpBinarioRichiestaUscita(this.requestBout, requestMessageType, contentTypeRichiesta, this.location, propertiesTrasportoDebug);
  320.             }
  321.             else {
  322.                 this.requestBout = new DumpByteArrayOutputStream(this.dumpBinario_soglia, this.dumpBinario_repositoryFile, this.idTransazione, 
  323.                         "NullEcho-"+TipoMessaggio.RICHIESTA_USCITA_DUMP_BINARIO.getValue()); 
  324.                 if(this.isSoap && this.sbustamentoSoap){
  325.                     this.logger.debug("Sbustamento...");
  326.                     TunnelSoapUtils.sbustamentoMessaggio(soapMessageRequest,this.requestBout);
  327.                 }else{
  328.                     this.requestMsg.writeTo(this.requestBout, consumeRequestMessage);
  329.                 }
  330.                 this.requestBout.flush();
  331.                 this.requestBout.close();
  332.                 
  333.                 this.dataRichiestaInoltrata = DateManager.getDate();
  334.             }
  335.             
  336.             /* ------------  PostOutRequestHandler ------------- */
  337.             this.postOutRequest();
  338.             
  339.             
  340.             
  341.             /* ------------  PreInResponseHandler ------------- */
  342.             this.preInResponse();
  343.             
  344.             // Lettura risposta parametri NotifierInputStream per la risposta
  345.             org.openspcoop2.utils.io.notifier.NotifierInputStreamParams notifierInputStreamParams = null;
  346.             if(this.preInResponseContext!=null){
  347.                 notifierInputStreamParams = this.preInResponseContext.getNotifierInputStreamParams();
  348.             }
  349.             
  350.             // operazione di gestione delle informaizoni crittografiche
  351.             this.retrieveCryptoInfo(pddContext);
  352.             

  354.             this.normalizeInputStreamResponse(readConnectionTimeout, readConnectionTimeoutConfigurazioneGlobale);
  355.             
  356.             this.initCheckContentTypeConfiguration();
  357.             
  358.             this.messageTypeResponse = this.requestMsg.getMessageType();
  359.             
  360.             if(this.isDumpBinarioRisposta()){
  361.                 this.dumpResponse(this.propertiesTrasportoRisposta);
  362.             }
  363.             
  364.             if(this.isResponse!=null) {
  365.                 this.emitDiagnosticResponseRead(this.isResponse);
  366.             }
  367.             
  368.             OpenSPCoop2MessageFactory messageFactory = Utilities.getOpenspcoop2MessageFactory(this.logger.getLogger(),this.requestMsg, this.requestInfo, MessageRole.RESPONSE);
  369.             OpenSPCoop2MessageParseResult pr;
  370.             
  371.             if (this.isResponse != null) {
  372.                 
  373.                 TransportResponseContext responseContext = new TransportResponseContext(this.logger.getLogger());
  374.                 responseContext.setCodiceTrasporto(this.codice+"");
  375.                 responseContext.setContentLength(this.contentLength);
  376.                 TransportUtils.addHeader(this.propertiesTrasportoRisposta, HttpConstants.CONTENT_TYPE, this.tipoRisposta);
  377.                 responseContext.setHeaders(this.propertiesTrasportoRisposta);
  378.                 
  379.                 pr = messageFactory.createMessage(this.messageTypeResponse, responseContext,
  380.                         this.isResponse,notifierInputStreamParams,
  381.                         this.openspcoopProperties.getAttachmentsProcessingMode());
  382.             } else {
  383.                 TransportResponseContext responseContext = new TransportResponseContext(this.logger.getLogger());
  384.                 responseContext.setContentLength(0);
  385.                 
  386.                 pr = messageFactory.createMessage(this.messageTypeResponse,responseContext,
  387.                         this.isResponse,notifierInputStreamParams,
  388.                         this.openspcoopProperties.getAttachmentsProcessingMode());
  389.             }
  390.             if(pr.getParseException()!=null){
  391.                 this.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, pr.getParseException());
  392.             }
  393.             
  394.             this.responseMsg = pr.getMessage_throwParseException();
  395.             
  396.             // content length
  397.             if(this.responseMsg!=null){
  398.                 this.contentLength = this.responseMsg.getIncomingMessageContentLength();
  399.             }
  400.             
  401.         }catch(Exception e){
  402.             this.eccezioneProcessamento = e;
  403.             String msgErrore = this.readExceptionMessageFromException(e);
  404.             if(this.generateErrorWithConnectorPrefix) {
  405.                 this.errore = "rilevata anomalia; "+msgErrore;
  406.             }
  407.             else {
  408.                 this.errore = msgErrore;
  409.             }
  410.             this.logger.error("Rilevata anomalia: "+msgErrore,e);
  411.             return false;
  412.         }
  413.         
  414.         return true;
  415.     }
  416.     
  417.     private void setRequestHeader(String key, String value, ConnettoreLogger logger, Map<String, List<String>> propertiesTrasportoDebug) throws Exception {
  418.         List<String> list = new ArrayList<>(); 
  419.         list.add(value);
  420.         this.setRequestHeader(key, list, logger, propertiesTrasportoDebug);
  421.     }
  422.     
  423.     private void setRequestHeader(String key, List<String> values, ConnettoreLogger logger, Map<String, List<String>> propertiesTrasportoDebug) throws Exception {
  424.         
  425.         if(this.debug && values!=null && !values.isEmpty()) {
  426.             for (String value : values) {
  427.                 logger.info("Set proprietà trasporto ["+key+"]=["+value+"]",false);     
  428.             }
  429.         }
  430.         setRequestHeader(key, values, propertiesTrasportoDebug);
  431.         
  432.     }
  433.     @Override
  434.     protected void setRequestHeader(String key,List<String> values) throws Exception {
  435.         this.propertiesTrasportoRisposta.put(key, values);
  436.     }
  437.     
  438.     /**
  439.      * Ritorna l'informazione su dove il connettore sta spedendo il messaggio
  440.      * 
  441.      * @return location di inoltro del messaggio
  442.      */
  443.     @Override
  444.     public String getLocation() throws ConnettoreException {
  445.         return LOCATION;
  446.     }

  448.     @Override
  449.     public void disconnect() throws ConnettoreException {
  450.         try {
  451.             if(this.requestBout!=null) {
  452.                 this.requestBout.clearResources();
  453.             }
  454.         }catch(Exception e) {
  455.             this.logger.error("Release resources failed: "+e.getMessage(), e);
  456.         }
  457.     }
  458. }




Created with JaCoCo 0.8.8.202204050719