ModIValidazioneSemantica.java

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



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

  25. import java.io.Serializable;
  26. import java.util.ArrayList;
  27. import java.util.Date;
  28. import java.util.List;

  30. import org.apache.commons.lang.StringUtils;
  31. import org.openspcoop2.core.config.PortaApplicativa;
  32. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneServizioApplicativo;
  33. import org.openspcoop2.core.config.ServizioApplicativo;
  34. import org.openspcoop2.core.config.constants.RuoloTipologia;
  35. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  36. import org.openspcoop2.core.constants.Costanti;
  37. import org.openspcoop2.core.constants.CostantiDB;
  38. import org.openspcoop2.core.constants.CostantiLabel;
  39. import org.openspcoop2.core.constants.TipoPdD;
  40. import org.openspcoop2.core.id.IDPortaApplicativa;
  41. import org.openspcoop2.core.id.IDServizio;
  42. import org.openspcoop2.core.id.IDServizioApplicativo;
  43. import org.openspcoop2.core.id.IDSoggetto;
  44. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  45. import org.openspcoop2.core.registry.Soggetto;
  46. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  47. import org.openspcoop2.message.OpenSPCoop2Message;
  48. import org.openspcoop2.message.constants.ServiceBinding;
  49. import org.openspcoop2.pdd.config.ConfigurazionePdDReader;
  50. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  51. import org.openspcoop2.pdd.config.PDNDResolver;
  52. import org.openspcoop2.pdd.core.CostantiPdD;
  53. import org.openspcoop2.pdd.core.token.InformazioniToken;
  54. import org.openspcoop2.pdd.core.token.TokenUtilities;
  55. import org.openspcoop2.pdd.core.token.parser.Claims;
  56. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  57. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  58. import org.openspcoop2.protocol.basic.validator.ValidazioneSemantica;
  59. import org.openspcoop2.protocol.engine.SecurityTokenUtilities;
  60. import org.openspcoop2.protocol.modipa.config.ModIProperties;
  61. import org.openspcoop2.protocol.modipa.constants.ModICostanti;
  62. import org.openspcoop2.protocol.modipa.utils.ModISecurityConfig;
  63. import org.openspcoop2.protocol.modipa.utils.ModIUtilities;
  64. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  65. import org.openspcoop2.protocol.sdk.Busta;
  66. import org.openspcoop2.protocol.sdk.Eccezione;
  67. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  68. import org.openspcoop2.protocol.sdk.ProtocolException;
  69. import org.openspcoop2.protocol.sdk.RestMessageSecurityToken;
  70. import org.openspcoop2.protocol.sdk.SecurityToken;
  71. import org.openspcoop2.protocol.sdk.constants.CodiceErroreCooperazione;
  72. import org.openspcoop2.protocol.sdk.constants.RuoloBusta;
  73. import org.openspcoop2.protocol.sdk.properties.ProtocolPropertiesUtils;
  74. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  75. import org.openspcoop2.protocol.sdk.state.IState;
  76. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  77. import org.openspcoop2.protocol.sdk.validator.ProprietaValidazione;
  78. import org.openspcoop2.protocol.sdk.validator.ValidazioneSemanticaResult;
  79. import org.openspcoop2.protocol.sdk.validator.ValidazioneUtils;
  80. import org.openspcoop2.protocol.utils.ModIUtils;
  81. import org.openspcoop2.protocol.utils.ModIValidazioneSemanticaProfiloSicurezza;
  82. import org.openspcoop2.utils.SortedMap;
  83. import org.openspcoop2.utils.certificate.remote.RemoteStoreConfig;
  84. import org.openspcoop2.utils.date.DateManager;
  85. import org.openspcoop2.utils.date.DateUtils;
  86. import org.openspcoop2.utils.digest.DigestEncoding;
  87. import org.openspcoop2.utils.properties.PropertiesUtilities;
  88. import org.openspcoop2.utils.transport.http.HttpConstants;



  92. /**
  93.  * Classe che implementa, in base al protocollo SdI, l'interfaccia {@link org.openspcoop2.protocol.sdk.validator.IValidazioneSemantica}
  94.  *
  95.  * @author Poli Andrea (apoli@link.it)
  96.  * @author $Author$
  97.  * @version $Rev$, $Date$
  98.  */

  100. public class ModIValidazioneSemantica extends ValidazioneSemantica {

  102.     /** ValidazioneUtils */
  103.     protected ValidazioneUtils validazioneUtils;
  104.     
  105.     /** Properties */
  106.     protected ModIProperties modiProperties;
  107.     
  108.     /** Errori di validazione riscontrati sulla busta */
  109.     protected java.util.List<Eccezione> erroriValidazione = new ArrayList<>();
  110.     /** Errori di processamento riscontrati sulla busta */
  111.     protected java.util.List<Eccezione> erroriProcessamento = new ArrayList<>();
  112.     
  113.     public ModIValidazioneSemantica(IProtocolFactory<?> factory, IState state) throws ProtocolException {
  114.         super(factory, state);
  115.         this.modiProperties = ModIProperties.getInstance();
  116.         this.validazioneUtils = new ValidazioneUtils(factory);
  117.     }

  119.     private static final String DIAGNOSTIC_VALIDATE = "validazioneSemantica";
  120.     private static final String DIAGNOSTIC_IN_CORSO = "inCorso";
  121.     private static final String DIAGNOSTIC_COMPLETATA = "completata";
  122.     private static final String DIAGNOSTIC_FALLITA = "fallita";
  123.     
  124.     private String getErroreClaimNonValido(String claim) {
  125.         return "Token contenente un claim '"+claim+"' non valido";
  126.     }
  127.     private String getErroreClaimNonPresente(String claim) {
  128.         return "Token non contiene il claim '"+claim+"'";
  129.     }
  130.     private Eccezione getErroreMittenteNonAutorizzato(Busta busta, String msgErrore) throws ProtocolException {
  131.         String idApp = busta.getServizioApplicativoFruitore() + " (Soggetto: "+busta.getMittente()+")";
  132.         return this.validazioneUtils.newEccezioneValidazione(CodiceErroreCooperazione.SICUREZZA_AUTORIZZAZIONE_FALLITA, 
  133.                 "Applicativo Mittente "+idApp+" non autorizzato"+(msgErrore!=null ? "; "+msgErrore: ""));
  134.     }
  135.     private void addErroreMittenteNonAutorizzato(Busta busta, String msgErrore) throws ProtocolException {
  136.         this.erroriValidazione.add(getErroreMittenteNonAutorizzato(busta, msgErrore));
  137.     }
  138.     
  139.     private static final String MSG_ERRORE_NON_PRESENTE = "non presente";
  140.     
  141.     private String getPrefixHeader(String hdr) {
  142.         return "[Header '"+hdr+"'] ";
  143.     }
  144.     
  145.     @Override
  146.     public ValidazioneSemanticaResult valida(OpenSPCoop2Message msg, Busta busta, 
  147.             ProprietaValidazione proprietaValidazione, 
  148.             RuoloBusta tipoBusta) throws ProtocolException{
  149.         
  150.         this.valida(msg,busta,tipoBusta, this.protocolFactory, this.state);
  151.         
  152.         java.util.List<Eccezione> erroriValidazioneList = null;
  153.         if(!this.erroriValidazione.isEmpty()){
  154.             erroriValidazioneList = this.erroriValidazione;
  155.             if(this.context!=null) {
  156.                 this.context.addObject(Costanti.ERRORE_VALIDAZIONE_PROTOCOLLO, Costanti.ERRORE_TRUE);
  157.             }
  158.         }
  159.         java.util.List<Eccezione> erroriProcessamentoList = null;
  160.         if(!this.erroriProcessamento.isEmpty()){
  161.             erroriValidazioneList = this.erroriProcessamento;
  162.         }
  163.         return new ValidazioneSemanticaResult(erroriValidazioneList, erroriProcessamentoList, null, null, null, null);
  164.         
  165.     }

  167.     private void valida(OpenSPCoop2Message msg,Busta busta, RuoloBusta tipoBusta, IProtocolFactory<?> factory, IState state) throws ProtocolException{
  168.         
  169.         MsgDiagnostico msgDiag = null;
  170.         String tipoDiagnostico = null;
  171.         boolean verifica = false;
  172.         boolean autorizzazione = false;
  173.         int sizeListaErroriValidazionePrimaAutorizzazione = -1;
  174.         int sizeListaProcessamentoValidazionePrimaAutorizzazione = -1;
  175.         try{
  176.         
  177.             String prefixIntegrity = getPrefixHeader(this.modiProperties.getRestSecurityTokenHeaderModI());
  178.             
  179.             RequestInfo requestInfo = null;
  180.             if(this.context!=null && this.context.containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  181.                 requestInfo = (RequestInfo) this.context.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  182.             }
  183.             
  184.             boolean isRichiesta = RuoloBusta.RICHIESTA.equals(tipoBusta);
  185.             
  186.             boolean rest = msg!=null && ServiceBinding.REST.equals(msg.getServiceBinding());
  187.             
  188.             if(busta==null) {
  189.                 throw new ProtocolException("Busta undefined");
  190.             }
  191.             
  192.             IRegistryReader registryReader = null;
  193.             
  194.             TipoPdD tipoPdD = isRichiesta ? TipoPdD.APPLICATIVA : TipoPdD.DELEGATA;
  195.             IDSoggetto idSoggetto = TipoPdD.DELEGATA.equals(tipoPdD) ? 
  196.                         new IDSoggetto(busta.getTipoMittente(),busta.getMittente()) : 
  197.                         new IDSoggetto(busta.getTipoDestinatario(),busta.getDestinatario());
  198.             if(idSoggetto==null || idSoggetto.getTipo()==null || idSoggetto.getNome()==null) {
  199.                 idSoggetto = OpenSPCoop2Properties.getInstance().getIdentitaPortaDefault(this.protocolFactory.getProtocol(), requestInfo);
  200.             }
  201.             else {
  202.                 registryReader = this.getProtocolFactory().getCachedRegistryReader(this.state, requestInfo);
  203.                 idSoggetto.setCodicePorta(registryReader.getDominio(idSoggetto));
  204.             }
  205.             msgDiag = MsgDiagnostico.newInstance(TipoPdD.DELEGATA, 
  206.                     idSoggetto,
  207.                     "ModI", requestInfo!=null && requestInfo.getProtocolContext()!=null ? requestInfo.getProtocolContext().getInterfaceName() : null,
  208.                     requestInfo,
  209.                     this.state);
  210.             if(TipoPdD.DELEGATA.equals(tipoPdD)){
  211.                 msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_CONTENUTI_APPLICATIVI);
  212.             }
  213.             else {
  214.                 msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_BUSTE);
  215.             }
  216.             msgDiag.setPddContext(this.context, this.protocolFactory);
  217.             tipoDiagnostico = isRichiesta ? ".richiesta." : ".risposta.";
  218.             
  219.             
  220.             Date now = DateManager.getDate();
  221.             
  222.             
  223.             ModIValidazioneSemanticaProfiloSicurezza modIValidazioneSemanticaProfiloSicurezza = new ModIValidazioneSemanticaProfiloSicurezza(busta, isRichiesta);
  224.             
  225.             boolean sicurezzaTokenOauth = modIValidazioneSemanticaProfiloSicurezza.isSicurezzaTokenOauth();
  226.             String securityMessageProfileSorgenteTokenIdAuth = modIValidazioneSemanticaProfiloSicurezza.getSecurityMessageProfileSorgenteTokenIdAuth();
  227.             
  228.             boolean sicurezzaMessaggio = modIValidazioneSemanticaProfiloSicurezza.isSicurezzaMessaggio();
  229.             boolean sicurezzaMessaggioIDAR04 = modIValidazioneSemanticaProfiloSicurezza.isSicurezzaMessaggioIDAR04();
  230.             
  231.             boolean sicurezzaAudit = modIValidazioneSemanticaProfiloSicurezza.isSicurezzaAudit();
  232.             String securityAuditPattern = modIValidazioneSemanticaProfiloSicurezza.getSecurityAuditPattern();
  233.             
  234.             if(sicurezzaMessaggio || sicurezzaAudit) {
  235.                 msgDiag.logPersonalizzato(DIAGNOSTIC_VALIDATE+tipoDiagnostico+DIAGNOSTIC_IN_CORSO);
  236.                 verifica=true;
  237.             }
  238.             
  239.             PortaApplicativa pa = null;
  240.             
  241.             RemoteStoreConfig rsc = null;
  242.             
  243.             if(isRichiesta && sicurezzaTokenOauth) {
  244.                 
  245.                 String prefixAuthorization = getPrefixHeader(HttpConstants.AUTHORIZATION);
  246.                 
  247.                 boolean sicurezzaToken = this.context.containsKey(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_INFORMAZIONI_NORMALIZZATE);
  248.                 if(!sicurezzaToken) {
  249.                 
  250.                     this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  251.                             CodiceErroreCooperazione.SICUREZZA_TOKEN_NON_PRESENTE, 
  252.                                 prefixAuthorization+MSG_ERRORE_NON_PRESENTE));
  253.                 }
  254.                 else {
  255.                 
  256.                     validateTokenAuthorizationId(msg,
  257.                             prefixAuthorization,
  258.                             modIValidazioneSemanticaProfiloSicurezza);
  259.                     
  260.                     boolean checkAudienceByModIConfig = sicurezzaMessaggio || sicurezzaAudit;
  261.                     pa = validateTokenAuthorizationAudience(msg, factory, state, requestInfo,
  262.                             isRichiesta, prefixAuthorization,
  263.                             checkAudienceByModIConfig);
  264.                                     
  265.                     PDNDResolver pdndResolver = new PDNDResolver(this.context, this.modiProperties.getRemoteStoreConfig());
  266.                     rsc = pdndResolver.enrichTokenInfo(requestInfo, sicurezzaMessaggio, sicurezzaAudit, idSoggetto);
  267.                 
  268.                     boolean claimValidi = validateTokenAuthorizationClaims(rsc, idSoggetto, isRichiesta, prefixAuthorization);
  269.                     if(claimValidi) {
  270.                         if(registryReader==null) {
  271.                             registryReader = this.getProtocolFactory().getCachedRegistryReader(this.state, requestInfo);
  272.                         }
  273.                         boolean isOk = validateTokenAuthorizationProducerIdByModIConfig(registryReader, idSoggetto, 
  274.                                 isRichiesta, prefixAuthorization);
  275.                         if(isOk) {
  276.                             validateTokenAuthorizationServiceDescriptorIdByModIConfig(registryReader, busta, 
  277.                                     isRichiesta, prefixAuthorization);
  278.                         }
  279.                     }
  280.                 }
  281.                 
  282.             }
  283.             
  284.             
  285.             if(sicurezzaMessaggio) {
  286.                 
  287.                 if(isRichiesta && sicurezzaTokenOauth) {
  288.                     String id = busta.getProperty(CostantiDB.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_ID);
  289.                     if( id==null || StringUtils.isEmpty(id) ) {
  290.                         // non c'era un token di integrita nonostante ne sia stato configurato (es. per GET) e sia stato indicato di utilizzarlo come identificativo messaggio.
  291.                         // per questo motivo in ricezione buste il metodo 'ModIUtils.replaceBustaIdWithJtiTokenId' non è stato invocato
  292.                         // Utilizzo come identificativo del messaggio quello presente nel voucher.
  293.                         String jti = TokenUtilities.readJtiFromInformazioniToken(this.context);
  294.                         if(jti!=null && StringUtils.isNotEmpty(jti)) {
  295.                             ModIUtils.replaceBustaIdWithJtiTokenId(modIValidazioneSemanticaProfiloSicurezza, jti);
  296.                             msgDiag.updateKeywordIdMessaggioRichiesta(busta.getID());
  297.                             if(this.context!=null) {
  298.                                 this.context.put(Costanti.MODI_JTI_REQUEST_ID_UPDATE_DIAGNOSTIC, busta.getID());
  299.                             }
  300.                         }
  301.                     }
  302.                 }
  303.                 
  304.                 String exp = busta.getProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_EXP);
  305.                 if(exp!=null) {
  306.                     checkExp(exp, now, rest, "");
  307.                 }
  308.                 
  309.                 String expIntegrity = busta.getProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_REST_INTEGRITY_EXP);
  310.                 if(expIntegrity!=null) {
  311.                     checkExp(expIntegrity, now, rest, prefixIntegrity);
  312.                 }
  313.                 
  314.                 String nbf = busta.getProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_NBF);
  315.                 if(nbf!=null) {
  316.                     checkNbf(nbf, now, "");
  317.                 }
  318.                 
  319.                 String nbfIntegrity = busta.getProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_REST_INTEGRITY_NBF);
  320.                 if(nbfIntegrity!=null) {
  321.                     checkNbf(nbfIntegrity, now, prefixIntegrity);
  322.                 }
  323.                 
  324.                 String iat = busta.getProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_IAT);
  325.                 if(iat!=null) {
  326.                     checkIat(iat, msg, rest, "");
  327.                 }
  328.                 
  329.                 String iatIntegrity = busta.getProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_REST_INTEGRITY_IAT);
  330.                 if(iatIntegrity!=null) {
  331.                     checkIat(iatIntegrity, msg, rest, prefixIntegrity);
  332.                 }
  333.                 
  334.                 String audienceBusta = busta.getProperty(rest ? 
  335.                         ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_REST_AUDIENCE :
  336.                         ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_SOAP_WSA_TO   );
  337.                 List<String> listAudienceBusta = null;
  338.                 if(rest && this.modiProperties.isRestSecurityTokenAudienceProcessArrayModeEnabled()) {
  339.                     listAudienceBusta = ModIUtilities.getArrayStringAsList(audienceBusta, true);
  340.                 }
  341.                 
  342.                 Object audienceAttesoObject = null;
  343.                 if(msg!=null) {
  344.                     audienceAttesoObject = msg.getContextProperty(ModICostanti.MODIPA_OPENSPCOOP2_MSG_CONTEXT_AUDIENCE_CHECK);
  345.                 }
  346.                 String audienceAtteso = null;
  347.                 if(audienceAttesoObject!=null) {
  348.                     audienceAtteso = (String) audienceAttesoObject;
  349.                 }
  350.                 
  351.                 Object audienceAttesoOAuthObject = null;
  352.                 if(msg!=null) {
  353.                     audienceAttesoOAuthObject = msg.getContextProperty(ModICostanti.MODIPA_OPENSPCOOP2_MSG_CONTEXT_AUDIENCE_CHECK_OAUTH);
  354.                 }
  355.                 String audienceOAuthAtteso = null;
  356.                 if(audienceAttesoOAuthObject!=null) {
  357.                     audienceOAuthAtteso = (String) audienceAttesoOAuthObject;
  358.                 }
  359.                 
  360.                 if(audienceAtteso!=null || audienceOAuthAtteso!=null) {
  361.                     
  362.                     boolean checkAudience = isAudienceValid(audienceAtteso, audienceBusta, listAudienceBusta);
  363.                     
  364.                     boolean checkAudienceOAuth = isAudienceValid(audienceOAuthAtteso, audienceBusta, listAudienceBusta);
  365.                     
  366.                     if(!checkAudience && !checkAudienceOAuth) {
  367.                         
  368.                         boolean buildSecurityTokenInRequest = true;
  369.                         Object buildSecurityTokenInRequestObject = msg.getContextProperty(ModICostanti.MODIPA_OPENSPCOOP2_MSG_CONTEXT_BUILD_SECURITY_REQUEST_TOKEN);
  370.                         if(buildSecurityTokenInRequestObject instanceof Boolean) {
  371.                             buildSecurityTokenInRequest = (Boolean) buildSecurityTokenInRequestObject;
  372.                         }
  373.                         
  374.                         if(isRichiesta || buildSecurityTokenInRequest) {
  375.                         
  376.                             this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  377.                                     isRichiesta ? CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_EROGATORE_NON_VALIDO :
  378.                                         CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_FRUITORE_NON_VALIDO, 
  379.                                         getErroreClaimNonValido(Claims.JSON_WEB_TOKEN_RFC_7519_AUDIENCE)));
  380.                             
  381.                         }
  382.                     }
  383.                 }
  384.                 if(rest) { 
  385.                     Object audienceIntegrityAttesoObject = null;
  386.                     if(msg!=null) {
  387.                         audienceIntegrityAttesoObject = msg.getContextProperty(ModICostanti.MODIPA_OPENSPCOOP2_MSG_CONTEXT_AUDIENCE_INTEGRITY_CHECK);
  388.                     }
  389.                     String audienceIntegrityAtteso = null;
  390.                     if(audienceIntegrityAttesoObject!=null) {
  391.                         audienceIntegrityAtteso = (String) audienceIntegrityAttesoObject;
  392.                     }
  393.                     
  394.                     Object audienceIntegrityAttesoOAuthObject = null;
  395.                     if(msg!=null) {
  396.                         audienceIntegrityAttesoOAuthObject = msg.getContextProperty(ModICostanti.MODIPA_OPENSPCOOP2_MSG_CONTEXT_AUDIENCE_INTEGRITY_CHECK_OAUTH);
  397.                     }
  398.                     String audienceIntegrityOAuthAtteso = null;
  399.                     if(audienceIntegrityAttesoOAuthObject!=null) {
  400.                         audienceIntegrityOAuthAtteso = (String) audienceIntegrityAttesoOAuthObject;
  401.                     }
  402.                     
  403.                     if(audienceIntegrityAtteso!=null || audienceIntegrityOAuthAtteso!=null) {
  404.                         String audienceIntegrityBusta = busta.getProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_REST_INTEGRITY_AUDIENCE);
  405.                         if(audienceIntegrityBusta==null) {
  406.                             // significa che l'audience tra i due token ricevuto e' identico
  407.                             audienceIntegrityBusta = busta.getProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_REST_AUDIENCE);
  408.                         }
  409.                         List<String> listAudienceIntegrityBusta = null;
  410.                         if(audienceIntegrityBusta!=null && rest && this.modiProperties.isRestSecurityTokenAudienceProcessArrayModeEnabled()) {
  411.                             listAudienceIntegrityBusta = ModIUtilities.getArrayStringAsList(audienceIntegrityBusta, true);
  412.                         }
  413.                         
  414.                         boolean checkAudience = isAudienceValid(audienceIntegrityAtteso, audienceIntegrityBusta, listAudienceIntegrityBusta);
  415.                         
  416.                         boolean checkAudienceOAuth = isAudienceValid(audienceIntegrityOAuthAtteso, audienceIntegrityBusta, listAudienceIntegrityBusta);
  417.                         
  418.                         if(!checkAudience && !checkAudienceOAuth) {
  419.                             this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  420.                                     isRichiesta ? CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_EROGATORE_NON_VALIDO :
  421.                                         CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_FRUITORE_NON_VALIDO, 
  422.                                     prefixIntegrity+getErroreClaimNonValido(Claims.JSON_WEB_TOKEN_RFC_7519_AUDIENCE)));
  423.                         }
  424.                     }
  425.                 }
  426.                 
  427.             }
  428.             
  429.             
  430.             
  431.             if(sicurezzaAudit) {
  432.             
  433.                 String prefixAudit = getPrefixHeader(this.modiProperties.getSecurityTokenHeaderModIAudit());
  434.                 
  435.                 boolean audit02 = CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN_AUDIT_REST_02.equals(securityAuditPattern);
  436.             
  437.                 String exp = busta.getProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_AUDIT_EXP);
  438.                 if(exp!=null) {
  439.                     checkExp(exp, now, rest, prefixAudit);
  440.                 }
  441.                 
  442.                 String nbf = busta.getProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_AUDIT_NBF);
  443.                 if(nbf!=null) {
  444.                     checkNbf(nbf, now, prefixAudit);
  445.                 }
  446.                 
  447.                 String iat = busta.getProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_AUDIT_IAT);
  448.                 if(iat!=null) {
  449.                     checkIat(iat, msg, rest, prefixAudit);
  450.                 }
  451.                 
  452.                 Object audienceAuditAttesoObject = null;
  453.                 if(msg!=null) {
  454.                     audienceAuditAttesoObject = msg.getContextProperty(ModICostanti.MODIPA_OPENSPCOOP2_MSG_CONTEXT_AUDIENCE_AUDIT_CHECK);
  455.                 }
  456.                 if(audienceAuditAttesoObject!=null) {
  457.                     String audienceAuditAtteso = (String) audienceAuditAttesoObject;
  458.                     String audienceAuditBusta = busta.getProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_AUDIT_AUDIENCE);
  459.                     if(audienceAuditBusta==null) {
  460.                         // significa che l'audience tra i due token ricevuto e' identico
  461.                         audienceAuditBusta = busta.getProperty(ModICostanti.MODIPA_BUSTA_EXT_PROFILO_SICUREZZA_MESSAGGIO_REST_AUDIENCE);
  462.                     }
  463.                     
  464.                     List<String> listAudienceAuditBusta = null;
  465.                     if(audienceAuditBusta!=null && this.modiProperties.isSecurityTokenAuditProcessArrayModeEnabled()) {
  466.                         listAudienceAuditBusta = ModIUtilities.getArrayStringAsList(audienceAuditBusta, true);
  467.                     }
  468.                     
  469.                     boolean checkAudienceAudit = isAudienceValid(audienceAuditAtteso, audienceAuditBusta, listAudienceAuditBusta);
  470.                     
  471.                     if(!checkAudienceAudit) {
  472.                         this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  473.                                 isRichiesta ? CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_EROGATORE_NON_VALIDO :
  474.                                     CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_FRUITORE_NON_VALIDO, 
  475.                                     prefixAudit+getErroreClaimNonValido(Claims.JSON_WEB_TOKEN_RFC_7519_AUDIENCE)));
  476.                     }
  477.                 }
  478.                 
  479.                 
  480.                 if(rsc!=null) {
  481.                     
  482.                     validatePurposeId(rsc, prefixAudit, securityAuditPattern);
  483.                     
  484.                 }
  485.                 
  486.                 if(audit02) {
  487.                     
  488.                     validateAudit02(securityMessageProfileSorgenteTokenIdAuth, rest, prefixAudit);
  489.                     
  490.                 }
  491.                 
  492.             }
  493.             
  494.             
  495.             if(verifica) {
  496.                 if(this.erroriValidazione.isEmpty() && this.erroriProcessamento.isEmpty()) {
  497.                     msgDiag.logPersonalizzato(DIAGNOSTIC_VALIDATE+tipoDiagnostico+DIAGNOSTIC_COMPLETATA);
  498.                 }
  499.                 else {
  500.                     String errore = null;
  501.                     if(!this.erroriValidazione.isEmpty()) {
  502.                         errore = ModIValidazioneSintattica.buildErrore(this.erroriValidazione, factory);
  503.                     }
  504.                     else {
  505.                         errore = ModIValidazioneSintattica.buildErrore(this.erroriProcessamento, factory);
  506.                     }
  507.                     msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, errore);
  508.                     msgDiag.logPersonalizzato(DIAGNOSTIC_VALIDATE+tipoDiagnostico+DIAGNOSTIC_FALLITA);
  509.                             
  510.                 }
  511.                 verifica = false;
  512.             }
  513.             
  514.             
  515.             
  516.             if(isRichiesta) {
  517.                 tipoDiagnostico = ".autorizzazione.";
  518.                 msgDiag.logPersonalizzato(DIAGNOSTIC_VALIDATE+tipoDiagnostico+DIAGNOSTIC_IN_CORSO);
  519.                 autorizzazione = true;
  520.                 sizeListaErroriValidazionePrimaAutorizzazione = this.erroriValidazione.size();
  521.                 sizeListaProcessamentoValidazionePrimaAutorizzazione = this.erroriProcessamento.size(); 
  522.                 
  523.                 
  524.                 // vale sia per sicurezza messaggio che per token
  525.                 // durante l'identificazione viene identificato 1 solo applicativo (non possono essere differenti tra token e trasporto)
  526.                 // viene quindi inserito dentro busta e usato per i controlli sottostanti
  527.                 
  528.                 if(pa==null) {
  529.                     String interfaceName = null;
  530.                     if(msg!=null && msg.getTransportRequestContext()!=null && msg.getTransportRequestContext().getInterfaceName()!=null) {
  531.                         interfaceName = msg.getTransportRequestContext().getInterfaceName();
  532.                     }
  533.                     else if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  534.                         interfaceName = requestInfo.getProtocolContext().getInterfaceName();
  535.                     }
  536.                     if(interfaceName==null) {
  537.                         throw new ProtocolException("ID Porta non presente");
  538.                     }
  539.                     IDPortaApplicativa idPA = new IDPortaApplicativa();
  540.                     idPA.setNome(interfaceName);
  541.                     pa = factory.getCachedConfigIntegrationReader(state, requestInfo).getPortaApplicativa(idPA); // pa invocata
  542.                 }
  543.                 
  544.                 
  545.                 /** Identificazione Mittente by LineeGuida e Token */
  546.                 boolean saIdentificatoBySecurity = busta.getServizioApplicativoFruitore()!=null && !CostantiPdD.SERVIZIO_APPLICATIVO_ANONIMO.equals(busta.getServizioApplicativoFruitore());
  547.                 
  548.                 boolean sicurezzaToken = this.context.containsKey(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_INFORMAZIONI_NORMALIZZATE);
  549.                 boolean saIdentificatoByToken = false;
  550.                 boolean saVerificatoBySecurity = false;
  551.                 if(sicurezzaToken) {
  552.                     IDServizioApplicativo idSAbyToken = null;
  553.                     StringBuilder sbError = new StringBuilder();
  554.                     try {
  555.                         idSAbyToken = IdentificazioneApplicativoMittenteUtils.identificazioneApplicativoMittenteByToken(this.log, state, busta, this.context, requestInfo, msgDiag, sbError);
  556.                     }catch(Exception e) {
  557.                         if(sbError!=null && sbError.length()>0) {
  558.                             this.context.addObject(Costanti.ERRORE_AUTORIZZAZIONE, Costanti.ERRORE_TRUE);
  559.                             this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(CodiceErroreCooperazione.SICUREZZA_AUTORIZZAZIONE_FALLITA, 
  560.                                     sbError.toString()));
  561.                             return;
  562.                         }
  563.                         else {
  564.                             throw e;
  565.                         }
  566.                     }
  567.                     saIdentificatoByToken = idSAbyToken!=null;
  568.                     
  569.                     if(saIdentificatoByToken) {
  570.                         /** && !saIdentificatoBySecurity) { 
  571.                         L'identificazione per sicurezza, se c'è abilitata l'autenticazione per token, non dovrebbe esserci mai poichè la funzionalità è stata disabilitata.
  572.                         Con autenticazione token attiva, gli applicativi anche se presente un x509 non vengono identificati dall'autenticazione https effettuata in AbstractModIValidazioneSintatticaCommons e di conseguenza in ModIValidazioneSintatticaRest e ModIValidazioneSintatticaSoap durante il trattamento del token di sicurezza
  573.                         bisogna quindi verificare, se è presente un certificato x509 di firma, che corrisponda a quello registrato nell'applicativo di tipo token identificato*/
  574.                         
  575.                         SecurityToken securityTokenForContext = SecurityTokenUtilities.readSecurityToken(this.context);
  576.                         if(securityTokenForContext!=null) {
  577.                             try {
  578.                                 if(securityTokenForContext.getAuthorization()!=null && securityTokenForContext.getAuthorization().getCertificate()!=null) {
  579.                                     sbError = new StringBuilder();
  580.                                     String tipoToken = //"Http Header "+
  581.                                             (securityTokenForContext.getAuthorization().getHttpHeaderName()!=null ? securityTokenForContext.getAuthorization().getHttpHeaderName() : HttpConstants.AUTHORIZATION);
  582.                                     IdentificazioneApplicativoMittenteUtils.checkApplicativoTokenByX509(this.log, idSAbyToken, 
  583.                                             state, requestInfo, tipoToken, securityTokenForContext.getAuthorization().getCertificate(), sbError);
  584.                                     saVerificatoBySecurity = true;
  585.                                 }
  586.                                 if(securityTokenForContext.getIntegrity()!=null && securityTokenForContext.getIntegrity().getCertificate()!=null) {
  587.                                     sbError = new StringBuilder();
  588.                                     String tipoToken = //"Http Header "+
  589.                                             (securityTokenForContext.getIntegrity().getHttpHeaderName()!=null ? securityTokenForContext.getIntegrity().getHttpHeaderName() : this.modiProperties.getRestSecurityTokenHeaderModI());
  590.                                     IdentificazioneApplicativoMittenteUtils.checkApplicativoTokenByX509(this.log, idSAbyToken, 
  591.                                             state, requestInfo, tipoToken, securityTokenForContext.getIntegrity().getCertificate(), sbError);
  592.                                     saVerificatoBySecurity = true;
  593.                                 }
  594.                                 if(securityTokenForContext.getEnvelope()!=null && securityTokenForContext.getEnvelope().getCertificate()!=null) {
  595.                                     sbError = new StringBuilder();
  596.                                     String tipoToken = "WSSecurity";
  597.                                     IdentificazioneApplicativoMittenteUtils.checkApplicativoTokenByX509(this.log, idSAbyToken, 
  598.                                             state, requestInfo, tipoToken, securityTokenForContext.getEnvelope().getCertificate(), sbError);
  599.                                     saVerificatoBySecurity = true;
  600.                                 }
  601.                             }catch(Exception e) {
  602.                                 if(sbError!=null && sbError.length()>0) {
  603.                                     this.context.addObject(Costanti.ERRORE_AUTORIZZAZIONE, Costanti.ERRORE_TRUE);
  604.                                     this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(CodiceErroreCooperazione.SICUREZZA_AUTORIZZAZIONE_FALLITA, 
  605.                                             sbError.toString()));
  606.                                     return;
  607.                                 }
  608.                                 else {
  609.                                     throw e;
  610.                                 }
  611.                             }
  612.                         }
  613.                         
  614.                     }
  615.                 }
  616.                 
  617.                 boolean saFruitoreAnonimo = busta.getServizioApplicativoFruitore()==null || CostantiPdD.SERVIZIO_APPLICATIVO_ANONIMO.equals(busta.getServizioApplicativoFruitore());
  618.                                 
  619.                 /** Tipi di Autorizzazione definiti */
  620.                 boolean autorizzazionePerRichiedente = false;
  621.                 if(pa.getAutorizzazioneToken()!=null) {
  622.                     autorizzazionePerRichiedente = StatoFunzionalita.ABILITATO.equals(pa.getAutorizzazioneToken().getAutorizzazioneApplicativi());
  623.                 }
  624.                 if(!autorizzazionePerRichiedente && pa.getServiziApplicativiAutorizzati()!=null) {
  625.                     // backward compatibility
  626.                     autorizzazionePerRichiedente = pa.getServiziApplicativiAutorizzati().sizeServizioApplicativoList()>0;
  627.                 }
  628.                 
  629.                 boolean autorizzazionePerRuolo = false;
  630.                 boolean checkRuoloRegistro = false;
  631.                 boolean checkRuoloEsterno = false;
  632.                 if(pa.getAutorizzazioneToken()!=null) {
  633.                     autorizzazionePerRuolo = StatoFunzionalita.ABILITATO.equals(pa.getAutorizzazioneToken().getAutorizzazioneRuoli());
  634.                 }
  635.                 if(autorizzazionePerRuolo) {
  636.                     if( pa.getAutorizzazioneToken().getTipologiaRuoli()==null ||
  637.                         RuoloTipologia.QUALSIASI.equals(pa.getAutorizzazioneToken().getTipologiaRuoli())){
  638.                         checkRuoloRegistro = true;
  639.                         checkRuoloEsterno = true;
  640.                     } 
  641.                     else if( RuoloTipologia.INTERNO.equals(pa.getAutorizzazioneToken().getTipologiaRuoli())){
  642.                         checkRuoloRegistro = true;
  643.                     }
  644.                     else if( RuoloTipologia.ESTERNO.equals(pa.getAutorizzazioneToken().getTipologiaRuoli())){
  645.                         checkRuoloEsterno = true;
  646.                     }
  647.                 }
  648.                 
  649.                 /** Verifica consistenza identificazione del mittente */
  650.                 if(
  651.                         (
  652.                                 autorizzazionePerRichiedente 
  653.                                 || 
  654.                                 (autorizzazionePerRuolo && checkRuoloRegistro && !checkRuoloEsterno)
  655.                         )
  656.                         &&
  657.                         saFruitoreAnonimo
  658.                 ){  
  659.                     this.context.addObject(Costanti.ERRORE_AUTORIZZAZIONE, Costanti.ERRORE_TRUE);
  660.                     this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(CodiceErroreCooperazione.SICUREZZA_AUTORIZZAZIONE_FALLITA, 
  661.                             "Applicativo Mittente non identificato"));
  662.                     return;
  663.                 }
  664.                 if(!saFruitoreAnonimo &&
  665.                     (autorizzazionePerRichiedente || checkRuoloRegistro) 
  666.                     ){
  667.                     // se utilizzo l'informazione dell'applicativo, tale informazione deve essere consistente rispetto a tutti i criteri di sicurezza
  668.                     if(sicurezzaMessaggio && !sicurezzaMessaggioIDAR04 &&
  669.                         !saIdentificatoBySecurity && !saVerificatoBySecurity) {
  670.                         this.context.addObject(Costanti.ERRORE_AUTORIZZAZIONE, Costanti.ERRORE_TRUE);
  671.                         addErroreMittenteNonAutorizzato(busta, "il certificato di firma non corrisponde all'applicativo");
  672.                         return;
  673.                     }
  674.                     if(sicurezzaToken &&
  675.                         !saIdentificatoByToken) {
  676.                         // CASO DEPRECATO: questo caso non puo' succedere poiche' nel caso di sicurezza token l'identificazione avviene SOLO per token
  677.                         //                 quindi si rientra nel caso sopra 'Applicativo Mittente non identificato'
  678.                         this.context.addObject(Costanti.ERRORE_AUTORIZZAZIONE, Costanti.ERRORE_TRUE);
  679.                         addErroreMittenteNonAutorizzato(busta, "il claim 'clientId' presente nel token non corrisponde all'applicativo");
  680.                         return;
  681.                     }
  682.                 }
  683.                 
  684.                 /** Autorizzazione per Richiedente */
  685.                 Eccezione eccezioneAutorizzazionePerRichiedente = null;
  686.                 if(autorizzazionePerRichiedente) {                  
  687.                     boolean autorizzato = false;
  688.                     if(pa.getServiziApplicativiAutorizzati()!=null) {
  689.                         for (PortaApplicativaAutorizzazioneServizioApplicativo paSA : pa.getServiziApplicativiAutorizzati().getServizioApplicativoList()) {
  690.                             if(paSA.getTipoSoggettoProprietario().equals(busta.getTipoMittente()) &&
  691.                                     paSA.getNomeSoggettoProprietario().equals(busta.getMittente()) &&
  692.                                     paSA.getNome().equals(busta.getServizioApplicativoFruitore())) {
  693.                                 autorizzato = true;
  694.                             }
  695.                         }
  696.                     }
  697.                     if(!autorizzato) {
  698.                         eccezioneAutorizzazionePerRichiedente = getErroreMittenteNonAutorizzato(busta, null);
  699.                     }
  700.                 }
  701.                 
  702.                 /** Autorizzazione per Ruolo */
  703.                 Eccezione eccezioneAutorizzazionePerRuolo = null;
  704.                 if(autorizzazionePerRuolo) {
  705.                     StringBuilder detailsBufferRuoli = new StringBuilder();
  706.                     ServizioApplicativo sa = null;
  707.                     if(!saFruitoreAnonimo) {
  708.                         IDServizioApplicativo idSA = new IDServizioApplicativo();
  709.                         idSA.setIdSoggettoProprietario(new IDSoggetto(busta.getTipoMittente(), busta.getMittente()));
  710.                         idSA.setNome(busta.getServizioApplicativoFruitore());
  711.                         sa = factory.getCachedConfigIntegrationReader(state,requestInfo).getServizioApplicativo(idSA);
  712.                     }
  713.                     boolean authRuoli = ConfigurazionePdDReader._autorizzazioneRoles(
  714.                                     RegistroServiziManager.getInstance(state),
  715.                                     null, sa, 
  716.                                     null, false, 
  717.                                     this.context, requestInfo,
  718.                                     checkRuoloRegistro, checkRuoloEsterno,
  719.                                     detailsBufferRuoli,
  720.                                     pa.getAutorizzazioneToken().getRuoli().getMatch(), pa.getAutorizzazioneToken().getRuoli(),
  721.                                     true);
  722.                     if(!authRuoli) {
  723.                         String errore = "Applicativo Mittente";
  724.                         if(!saFruitoreAnonimo) {
  725.                             errore = errore + " "+ busta.getServizioApplicativoFruitore() + " (Soggetto: "+busta.getMittente()+")";
  726.                         }
  727.                         errore = errore + " non autorizzato; ";
  728.                         eccezioneAutorizzazionePerRuolo = this.validazioneUtils.newEccezioneValidazione(CodiceErroreCooperazione.SICUREZZA_AUTORIZZAZIONE_FALLITA, 
  729.                                 errore + detailsBufferRuoli.toString());
  730.                     }
  731.                 }
  732.                 
  733.                 /** Gestione Eccezioni */
  734.                 if(autorizzazionePerRichiedente && autorizzazionePerRuolo) {
  735.                     if(eccezioneAutorizzazionePerRichiedente!=null && eccezioneAutorizzazionePerRuolo!=null) {
  736.                         this.context.addObject(Costanti.ERRORE_AUTORIZZAZIONE, Costanti.ERRORE_TRUE);
  737.                         this.erroriValidazione.add(eccezioneAutorizzazionePerRuolo); // uso eccezione per ruolo che e' più completa come messaggistica
  738.                     }
  739.                     // se una delle due autorizzazione e' andata a buon fine devo autorizzare
  740.                 }
  741.                 else {
  742.                     if(eccezioneAutorizzazionePerRichiedente!=null || eccezioneAutorizzazionePerRuolo!=null) {
  743.                         this.context.addObject(Costanti.ERRORE_AUTORIZZAZIONE, Costanti.ERRORE_TRUE);
  744.                         if(eccezioneAutorizzazionePerRichiedente!=null) {
  745.                             this.erroriValidazione.add(eccezioneAutorizzazionePerRichiedente); 
  746.                         }
  747.                         else {
  748.                             this.erroriValidazione.add(eccezioneAutorizzazionePerRuolo);
  749.                         }
  750.                     }
  751.                 }
  752.             
  753.                 
  754.                 int sizeListaEccezioniPrimaAutorizzazione = sizeListaErroriValidazionePrimaAutorizzazione + sizeListaProcessamentoValidazionePrimaAutorizzazione; 
  755.                 int sizeListaEccezioniDipoAutorizzazione = this.erroriValidazione.size() + this.erroriProcessamento.size(); 
  756.                 if(sizeListaEccezioniPrimaAutorizzazione == sizeListaEccezioniDipoAutorizzazione) {
  757.                     msgDiag.logPersonalizzato(DIAGNOSTIC_VALIDATE+tipoDiagnostico+DIAGNOSTIC_COMPLETATA);
  758.                 }
  759.                 else {
  760.                     String errore = null;
  761.                     if(sizeListaErroriValidazionePrimaAutorizzazione!=this.erroriValidazione.size()) {
  762.                         errore = ModIValidazioneSintattica.buildErrore(this.erroriValidazione, sizeListaErroriValidazionePrimaAutorizzazione, factory);
  763.                     }
  764.                     else {
  765.                         errore = ModIValidazioneSintattica.buildErrore(this.erroriProcessamento, sizeListaProcessamentoValidazionePrimaAutorizzazione, factory);
  766.                     }
  767.                     msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, errore);
  768.                     msgDiag.logPersonalizzato(DIAGNOSTIC_VALIDATE+tipoDiagnostico+DIAGNOSTIC_FALLITA);  
  769.                 }
  770.                 autorizzazione = false;
  771.             
  772.             } // fine autorizzazione
  773.             
  774.             
  775.         }catch(Exception e){
  776.             
  777.             if(msgDiag!=null && (verifica || autorizzazione)) {
  778.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, e.getMessage());
  779.                 msgDiag.logPersonalizzato(DIAGNOSTIC_VALIDATE+tipoDiagnostico+DIAGNOSTIC_FALLITA);
  780.             }
  781.             
  782.             this.erroriProcessamento.add(this.validazioneUtils.newEccezioneProcessamento(CodiceErroreCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO, 
  783.                     e.getMessage(),e));
  784.         }
  785.     }
  786.     
  787.     private boolean isAudienceValid(String audienceAtteso, String audience, List<String> listAudience) {
  788.         boolean checkAudience = false;
  789.         if(audienceAtteso!=null) {
  790.             checkAudience = audienceAtteso.equals(audience);
  791.             if(!checkAudience && listAudience!=null && !listAudience.isEmpty()) {
  792.                 for (String check : listAudience) {
  793.                     if(audienceAtteso.equals(check)) {
  794.                         checkAudience = true;
  795.                         break;
  796.                     }
  797.                 }
  798.             }
  799.         }
  800.         return checkAudience;
  801.     }

  803.     private void checkExp(String exp, Date now, boolean rest, String prefix) throws ProtocolException {
  804.         
  805.         boolean enabled = true;
  806.         if(rest) {
  807.             enabled = this.modiProperties.isRestSecurityTokenClaimsExpTimeCheck();
  808.         }
  809.         else {
  810.             enabled = this.modiProperties.isSoapSecurityTokenTimestampExpiresTimeCheck();
  811.         }
  812.         if(!enabled) {
  813.             return;
  814.         }
  815.         
  816.         if(prefix==null) {
  817.             prefix="";
  818.         }
  819.         Date dateExp = null;
  820.         try {
  821.             dateExp = DateUtils.getSimpleDateFormatMs().parse(exp);
  822.         }catch(Exception e) {
  823.             throw new ProtocolException(e.getMessage(),e);
  824.         }
  825.         /*
  826.          *   The "exp" (expiration time) claim identifies the expiration time on
  827.              *   or after which the JWT MUST NOT be accepted for processing.  The
  828.              *   processing of the "exp" claim requires that the current date/time
  829.              *   MUST be before the expiration date/time listed in the "exp" claim.
  830.          **/
  831.         Date checkNow = now;
  832.         Long tolerance = null;
  833.         if(rest) {
  834.             tolerance = this.modiProperties.getRestSecurityTokenClaimsExpTimeCheckToleranceMilliseconds();
  835.         }
  836.         else {
  837.             tolerance = this.modiProperties.getSoapSecurityTokenTimestampExpiresTimeCheckToleranceMilliseconds();
  838.         }
  839.         if(tolerance!=null && tolerance.longValue()>0) {
  840.             checkNow = new Date(now.getTime() - tolerance.longValue());
  841.         }
  842.         if(!checkNow.before(dateExp)){
  843.             this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(CodiceErroreCooperazione.MESSAGGIO_SCADUTO, 
  844.                     prefix+"Token scaduto in data '"+exp+"'"));
  845.         }
  846.     }
  847.     
  848.     private void checkNbf(String nbf, Date now, String prefix) throws ProtocolException {
  849.         if(prefix==null) {
  850.             prefix="";
  851.         }
  852.         Date dateNbf = null;
  853.         try {
  854.             dateNbf = DateUtils.getSimpleDateFormatMs().parse(nbf);
  855.         }catch(Exception e) {
  856.             throw new ProtocolException(e.getMessage(),e);
  857.         }
  858.         /*
  859.          *   The "nbf" (not before) claim identifies the time before which the JWT
  860.          *   MUST NOT be accepted for processing.  The processing of the "nbf"
  861.          *   claim requires that the current date/time MUST be after or equal to
  862.          *   the not-before date/time listed in the "nbf" claim. 
  863.          **/
  864.         
  865.         Long future = this.modiProperties.getRestSecurityTokenClaimsNbfTimeCheckToleranceMilliseconds();
  866.         Date futureMax = now;
  867.         if(future!=null && future.longValue()>0) {
  868.             futureMax = new Date((now.getTime() + future.longValue()));
  869.         }
  870.         
  871.         if(!dateNbf.before(futureMax)){
  872.             this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(CodiceErroreCooperazione.MESSAGGIO_SCADUTO, 
  873.                     prefix+"Token non utilizzabile prima della data '"+nbf+"'"));
  874.         }
  875.     }
  876.     
  877.     private void checkIat(String iat, OpenSPCoop2Message msg, boolean rest, String prefix) throws ProtocolException {
  878.         if(prefix==null) {
  879.             prefix="";
  880.         }
  881.         Date dateIat = null;
  882.         try {
  883.             dateIat = DateUtils.getSimpleDateFormatMs().parse(iat);
  884.         }catch(Exception e) {
  885.             throw new ProtocolException(e.getMessage(),e);
  886.         }
  887.         /*
  888.          *   The "iat" (issued at) claim identifies the time at which the JWT was
  889.              *   issued.  This claim can be used to determine the age of the JWT.
  890.              *   The iat Claim can be used to reject tokens that were issued too far away from the current time, 
  891.              *   limiting the amount of time that nonces need to be stored to prevent attacks. The acceptable range is Client specific. 
  892.          **/
  893.         Long old = null;
  894.         Object iatObject = null;
  895.         if(msg!=null) {
  896.             iatObject = msg.getContextProperty(ModICostanti.MODIPA_OPENSPCOOP2_MSG_CONTEXT_IAT_TTL_CHECK);
  897.         }
  898.         if(iatObject instanceof Long) {
  899.             old = (Long) iatObject;
  900.         }
  901.         if(old==null) {
  902.             if(rest) {
  903.                 old = this.modiProperties.getRestSecurityTokenClaimsIatTimeCheckMilliseconds();
  904.             }
  905.             else {
  906.                 old = this.modiProperties.getSoapSecurityTokenTimestampCreatedTimeCheckMilliseconds();
  907.             }
  908.         }
  909.         if(old!=null) {
  910.             Date oldMax = new Date((DateManager.getTimeMillis() - old.longValue()));
  911.             if(dateIat.before(oldMax)) {
  912.                 logError(prefix+"Token creato da troppo tempo (data creazione: '"+iat+"', data più vecchia consentita: '"+DateUtils.getSimpleDateFormatMs().format(oldMax)+"', configurazione ms: '"+old.longValue()+"')");
  913.                 this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(CodiceErroreCooperazione.MESSAGGIO_SCADUTO, 
  914.                         prefix+"Token creato da troppo tempo (data creazione: '"+iat+"')"));
  915.             }
  916.         }
  917.         
  918.         
  919.         checkIatFuture(dateIat, prefix, iat, rest);
  920.     }
  921.     private void checkIatFuture(Date dateIat, String prefix, String iat, boolean rest) throws ProtocolException {
  922.         Long future = null;
  923.         if(rest) {
  924.             future = this.modiProperties.getRestSecurityTokenClaimsIatTimeCheckFutureToleranceMilliseconds();
  925.         }
  926.         else {
  927.             future = this.modiProperties.getSoapSecurityTokenTimestampCreatedTimeCheckFutureToleranceMilliseconds();
  928.         }
  929.         if(future!=null && future.longValue()>0) {
  930.             Date futureMax = new Date((DateManager.getTimeMillis() + future.longValue()));
  931.             if(dateIat.after(futureMax)) {
  932.                 logError(prefix+"Token creato nel futuro (data creazione: '"+iat+"', data massima futura consentita: '"+DateUtils.getSimpleDateFormatMs().format(futureMax)+"', configurazione ms: '"+future.longValue()+"')");
  933.                 this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(CodiceErroreCooperazione.ORA_REGISTRAZIONE_NON_VALIDA, 
  934.                         prefix+"Token creato nel futuro (data creazione: '"+iat+"')"));
  935.             }
  936.         }
  937.     }
  938.     
  939.     private void validatePurposeId(RemoteStoreConfig rsc, String prefixAudit, String securityAuditPattern) throws ProtocolException {
  940.         
  941.         try {
  942.             if(rsc!=null &&
  943.                     (this.modiProperties.isSecurityTokenAuditExpectedPurposeId() || this.modiProperties.isSecurityTokenAuditCompareAuthorizationPurposeId())) {
  944.             
  945.                 SecurityToken securityToken = ModIUtilities.readSecurityToken(this.context);
  946.                 if(securityToken==null) {
  947.                     this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  948.                             CodiceErroreCooperazione.SICUREZZA_NON_PRESENTE, 
  949.                             "Token di sicurezza non presenti"));
  950.                     return;
  951.                 }
  952.                 
  953.                 RestMessageSecurityToken restSecurityToken = securityToken.getAccessToken();

  955.                 String prefixAuthorization = getPrefixHeader(HttpConstants.AUTHORIZATION);
  956.                 String labelAuditPattern = CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN_AUDIT_REST_02.equals(securityAuditPattern) ? 
  957.                         CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN_AUDIT_REST_02 : CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN_AUDIT_REST_01;
  958.                 String suffixAudit02 = " (richiesto con pattern '"+labelAuditPattern+"')";
  959.                 if(restSecurityToken==null) {
  960.                     this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  961.                             CodiceErroreCooperazione.SICUREZZA_NON_PRESENTE, 
  962.                             prefixAuthorization+MSG_ERRORE_NON_PRESENTE+suffixAudit02));
  963.                     return;
  964.                 }
  965.                 
  966.                 RestMessageSecurityToken auditToken = securityToken.getAudit();
  967.                 if(auditToken==null) {
  968.                     this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  969.                             CodiceErroreCooperazione.SICUREZZA_NON_PRESENTE, 
  970.                             prefixAudit+MSG_ERRORE_NON_PRESENTE));
  971.                     return;
  972.                 }
  973.                 
  974.                 boolean expected = this.modiProperties.isSecurityTokenAuditExpectedPurposeId();
  975.                 String purposeIdAuthorization = readPurposeId(restSecurityToken, prefixAuthorization, expected);
  976.                 String purposeIdAudit = readPurposeId(auditToken, prefixAudit, expected);
  977.                 
  978.                 if(this.modiProperties.isSecurityTokenAuditCompareAuthorizationPurposeId() &&
  979.                     purposeIdAuthorization!=null && purposeIdAudit!=null && !purposeIdAuthorization.equals(purposeIdAudit)) {
  980.                     String claim = org.openspcoop2.pdd.core.token.Costanti.PDND_PURPOSE_ID;
  981.                     this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  982.                             CodiceErroreCooperazione.SICUREZZA_NON_PRESENTE, 
  983.                             prefixAudit+"Claim '"+claim+"' presente nel token contiene un valore '"+purposeIdAudit+"' differente da quello presente nel token "+HttpConstants.AUTHORIZATION+" ("+purposeIdAuthorization+")"));
  984.                 }
  985.             }
  986.         }catch(Exception e) {
  987.             throw new ProtocolException(e.getMessage(),e);
  988.         }

  990.     }
  991.     private String readPurposeId(RestMessageSecurityToken restSecurityToken, String prefixAuthorization, boolean required) throws ProtocolException {
  992.         String purposeId = null;
  993.         String purposeIdClaim = org.openspcoop2.pdd.core.token.Costanti.PDND_PURPOSE_ID;
  994.         try {
  995.             purposeId = restSecurityToken.getPayloadClaim(purposeIdClaim);
  996.             if( (purposeId==null || StringUtils.isEmpty(purposeId)) && required ) {
  997.                 this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  998.                         CodiceErroreCooperazione.SICUREZZA_TOKEN_NON_VALIDO, 
  999.                         prefixAuthorization+getErroreClaimNonPresente(purposeIdClaim)));
  1000.             }
  1001.         }catch(Exception e) {
  1002.             logError("Lettura purpose id token fallita: "+e.getMessage(),e);
  1003.             this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1004.                     CodiceErroreCooperazione.SICUREZZA_TOKEN_NON_VALIDO, 
  1005.                     prefixAuthorization+getErroreClaimNonValido(purposeIdClaim)));
  1006.         }
  1007.         return purposeId;
  1008.     }
  1009.     
  1010.     private void validateAudit02(String securityMessageProfileSorgenteTokenIdAuth, boolean rest, String prefixAudit) throws ProtocolException {
  1011.         boolean expectedAccessToken = false;
  1012.         if(ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN_IDAUTH_VALUE_PDND.equals(securityMessageProfileSorgenteTokenIdAuth) ||
  1013.                 ModICostanti.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN_IDAUTH_VALUE_OAUTH.equals(securityMessageProfileSorgenteTokenIdAuth)) {
  1014.             expectedAccessToken = true;
  1015.         }
  1016.         
  1017.         SecurityToken securityToken = ModIUtilities.readSecurityToken(this.context);
  1018.         if(securityToken==null) {
  1019.             this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1020.                     CodiceErroreCooperazione.SICUREZZA_NON_PRESENTE, 
  1021.                     "Token di sicurezza non presenti"));
  1022.             return;
  1023.         }
  1024.         
  1025.         RestMessageSecurityToken restSecurityToken = null;
  1026.         if(expectedAccessToken) {
  1027.             restSecurityToken = securityToken.getAccessToken();
  1028.         }
  1029.         else {
  1030.             if(rest) {
  1031.                 restSecurityToken = securityToken.getAuthorization();
  1032.             }
  1033.             else {
  1034.                 this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1035.                         CodiceErroreCooperazione.SICUREZZA_TOKEN_NON_VALIDO, 
  1036.                         "Token di sicurezza IDAuth Locale su API Soap non è utilizzabile con pattern "+CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN_AUDIT_REST_02));
  1037.                 return;
  1038.             }
  1039.         }
  1040.         String prefixAuthorization = getPrefixHeader(HttpConstants.AUTHORIZATION);
  1041.         String suffixAudit02 = " (richiesto con pattern '"+CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN_AUDIT_REST_02+"')";
  1042.         if(restSecurityToken==null) {
  1043.             this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1044.                     CodiceErroreCooperazione.SICUREZZA_NON_PRESENTE, 
  1045.                     prefixAuthorization+MSG_ERRORE_NON_PRESENTE+suffixAudit02));
  1046.             return;
  1047.         }
  1048.         
  1049.         String digestClaimPrefix = org.openspcoop2.pdd.core.token.Costanti.PDND_DIGEST+".";
  1050.         
  1051.         String digestAlgo = readDigestAlgorithm(digestClaimPrefix, restSecurityToken, prefixAuthorization);
  1052.         String digestValue = readDigestValue(digestClaimPrefix, restSecurityToken, prefixAuthorization);
  1053.         if(digestAlgo==null || digestValue==null) {
  1054.             return; // errori gestiti nei metodi sopra
  1055.         }
  1056.         
  1057.         
  1058.         RestMessageSecurityToken auditSecurityToken = securityToken.getAudit();
  1059.         if(auditSecurityToken==null || auditSecurityToken.getToken()==null || StringUtils.isEmpty(auditSecurityToken.getToken())) {
  1060.             this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1061.                     CodiceErroreCooperazione.SICUREZZA_TOKEN_NON_PRESENTE, 
  1062.                     prefixAudit+MSG_ERRORE_NON_PRESENTE));
  1063.             return;
  1064.         }
  1065.         
  1066.         // calcolo digest value token audit
  1067.         String digestAuditRicalcolato = null;
  1068.         try {
  1069.             digestAuditRicalcolato = org.openspcoop2.utils.digest.DigestUtils.getDigestValue(auditSecurityToken.getToken().getBytes(), digestAlgo, DigestEncoding.HEX, 
  1070.                     false); // se rfc3230 true aggiunge prefisso algoritmo=
  1071.         }catch(Exception e) {
  1072.             logError("Calcolo digest del token di audit fallito: "+e.getMessage(),e);
  1073.             this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1074.                     CodiceErroreCooperazione.SICUREZZA, 
  1075.                     prefixAudit+"check digest failed"));
  1076.             return;
  1077.         }
  1078.         if(!digestValue.equalsIgnoreCase(digestAuditRicalcolato)) {
  1079.             String digestValueClaim = digestClaimPrefix+org.openspcoop2.pdd.core.token.Costanti.PDND_DIGEST_VALUE;
  1080.             this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1081.                     CodiceErroreCooperazione.SICUREZZA_TOKEN_NON_VALIDO, 
  1082.                     prefixAuthorization+"possiede un valore nel campo '"+digestValueClaim+"' non corrispondente al token di audit previsto dal pattern '"+CostantiLabel.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN_AUDIT_REST_02+"'"));
  1083.         }
  1084.         
  1085.     }
  1086.     
  1087.     private String readDigestAlgorithm(String digestClaimPrefix, RestMessageSecurityToken restSecurityToken, String prefixAuthorization) throws ProtocolException {
  1088.         String digestAlgo = null;
  1089.         String digestAlgClaim = digestClaimPrefix+org.openspcoop2.pdd.core.token.Costanti.PDND_DIGEST_ALG;
  1090.         try {
  1091.             digestAlgo = restSecurityToken.getPayloadClaim(digestAlgClaim);
  1092.             if(digestAlgo==null || StringUtils.isEmpty(digestAlgo)) {
  1093.                 this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1094.                         CodiceErroreCooperazione.SICUREZZA_TOKEN_NON_VALIDO, 
  1095.                         prefixAuthorization+getErroreClaimNonPresente(digestAlgClaim)));
  1096.             }
  1097.         }catch(Exception e) {
  1098.             logError("Lettura algoritmo di digest in authorization token fallita: "+e.getMessage(),e);
  1099.             this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1100.                     CodiceErroreCooperazione.SICUREZZA_TOKEN_NON_VALIDO, 
  1101.                     prefixAuthorization+getErroreClaimNonValido(digestAlgClaim)));
  1102.         }
  1103.         return digestAlgo;
  1104.     }
  1105.     private String readDigestValue(String digestClaimPrefix, RestMessageSecurityToken restSecurityToken, String prefixAuthorization) throws ProtocolException {
  1106.         String digestValue = null;
  1107.         String digestValueClaim = digestClaimPrefix+org.openspcoop2.pdd.core.token.Costanti.PDND_DIGEST_VALUE;
  1108.         try {
  1109.             digestValue = restSecurityToken.getPayloadClaim(digestValueClaim);
  1110.             if(digestValue==null || StringUtils.isEmpty(digestValue)) {
  1111.                 this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1112.                         CodiceErroreCooperazione.SICUREZZA_TOKEN_NON_VALIDO, 
  1113.                         prefixAuthorization+getErroreClaimNonPresente(digestValueClaim)));
  1114.             }
  1115.         }catch(Exception e) {
  1116.             logError("Lettura valore del digest audit in authorization token fallita: "+e.getMessage(),e);
  1117.             this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1118.                     CodiceErroreCooperazione.SICUREZZA_TOKEN_NON_VALIDO, 
  1119.                     prefixAuthorization+getErroreClaimNonValido(digestValueClaim)));
  1120.         }
  1121.         return digestValue;
  1122.     }
  1123.     
  1124.     
  1125.     private void validateTokenAuthorizationId(OpenSPCoop2Message msg,
  1126.             String prefixAuthorization,
  1127.             ModIValidazioneSemanticaProfiloSicurezza modIValidazioneSemanticaProfiloSicurezza) throws ProtocolException {
  1128.     
  1129.         boolean useJtiAuthorization = ModIUtils.useJtiAuthorizationObject(msg);
  1130.         if(useJtiAuthorization) {
  1131.             String jtiClaimReceived = TokenUtilities.readJtiFromInformazioniToken(this.context);            
  1132.             if(jtiClaimReceived==null || StringUtils.isEmpty(jtiClaimReceived)) {
  1133.                 
  1134.                 this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1135.                         CodiceErroreCooperazione.IDENTIFICATIVO_MESSAGGIO_NON_PRESENTE, 
  1136.                             prefixAuthorization+getErroreClaimNonPresente(Claims.JSON_WEB_TOKEN_RFC_7519_JWT_ID)));
  1137.                 
  1138.             }
  1139.             else {
  1140.                 
  1141.                 if(modIValidazioneSemanticaProfiloSicurezza!=null) {
  1142.                     // nop
  1143.                 }
  1144.                 /** SPOSTATO IN RICEZIONE BUSTE per generare il corretto idMessaggio */
  1145.                 /**ModIUtils.replaceBustaIdWithJtiTokenId(modIValidazioneSemanticaProfiloSicurezza, jtiClaimReceived);*/
  1146.                 
  1147.             }
  1148.         }
  1149.         
  1150.     }
  1151.     
  1152.     private PortaApplicativa validateTokenAuthorizationAudience(OpenSPCoop2Message msg, IProtocolFactory<?> factory, IState state, RequestInfo requestInfo,
  1153.             boolean isRichiesta, String prefixAuthorization,
  1154.             boolean checkAudienceByModIConfig) throws ProtocolException {
  1155.         
  1156.         PortaApplicativa pa = readPortaApplicativa(msg, factory, state, requestInfo);
  1157.         
  1158.         boolean audienceCheckDefinedInAuthorizationTokenClaims = isAudienceCheckDefinedInAuthorizationTokenClaims(pa);
  1159.     
  1160.         if(!audienceCheckDefinedInAuthorizationTokenClaims) {
  1161.             
  1162.             validateTokenAuthorizationAudienceByModIConfig(msg, factory, state, requestInfo,
  1163.                     isRichiesta, prefixAuthorization,
  1164.                     checkAudienceByModIConfig);
  1165.             
  1166.         }
  1167.         
  1168.         return pa;
  1169.     }
  1170.     
  1171.     private void validateTokenAuthorizationAudienceByModIConfig(OpenSPCoop2Message msg, IProtocolFactory<?> factory, IState state, RequestInfo requestInfo,
  1172.             boolean isRichiesta, String prefixAuthorization,
  1173.             boolean checkAudienceByModIConfig) throws ProtocolException {
  1174.         List<String> audienceClaimReceived = readAudienceFromTokenOAuth();          
  1175.         if(audienceClaimReceived==null || audienceClaimReceived.isEmpty()) {
  1176.             
  1177.             this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1178.                     isRichiesta ? CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_EROGATORE_NON_PRESENTE :
  1179.                         CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_FRUITORE_NON_PRESENTE, 
  1180.                         prefixAuthorization+getErroreClaimNonPresente(Claims.JSON_WEB_TOKEN_RFC_7519_AUDIENCE)));
  1181.             
  1182.         }
  1183.         else {
  1184.         
  1185.             if(checkAudienceByModIConfig) {
  1186.                 checkAudienceModIConfig(msg, factory, state, requestInfo,
  1187.                         isRichiesta, prefixAuthorization,
  1188.                         audienceClaimReceived);
  1189.             }
  1190.             else {
  1191.                 
  1192.                 this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1193.                         isRichiesta ? CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_EROGATORE_NON_VALIDO :
  1194.                             CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_FRUITORE_NON_VALIDO, 
  1195.                             prefixAuthorization+"Token contenente un claim '"+Claims.JSON_WEB_TOKEN_RFC_7519_AUDIENCE+"' non verificabile; autorizzazione per token claim non definita"));
  1196.                 
  1197.             }
  1198.             
  1199.         }
  1200.     }
  1201.     
  1202.     private boolean validateTokenAuthorizationClaims(RemoteStoreConfig rsc, IDSoggetto idSoggetto,
  1203.             boolean isRichiesta, String prefixAuthorization) throws ProtocolException{
  1204.         // valido claims obbligatori
  1205.         List<String> claimsAttesi = null;
  1206.         if(rsc!=null) {
  1207.             claimsAttesi = this.modiProperties.getValidazioneTokenPDNDClaimsRequired(idSoggetto.getNome()); 
  1208.         }
  1209.         else {
  1210.             claimsAttesi = this.modiProperties.getValidazioneTokenOAuthClaimsRequired(idSoggetto.getNome());    
  1211.         }
  1212.         if(claimsAttesi!=null && !claimsAttesi.isEmpty()) {
  1213.             for (String claim : claimsAttesi) {
  1214.                 String claimValue = readClaimFromTokenOAuth(claim); 
  1215.                 if(claimValue==null || StringUtils.isEmpty(claimValue)) {
  1216.                     this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1217.                             isRichiesta ? CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_EROGATORE_NON_PRESENTE :
  1218.                                 CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_FRUITORE_NON_PRESENTE, 
  1219.                                 prefixAuthorization+getErroreClaimNonPresente(claim)));
  1220.                     return false;
  1221.                     
  1222.                 }
  1223.             }
  1224.         }
  1225.         return true;
  1226.     }
  1227.     
  1228.     private boolean validateTokenAuthorizationProducerIdByModIConfig(IRegistryReader registryReader, IDSoggetto idSoggetto, 
  1229.             boolean isRichiesta, String prefixAuthorization) throws ProtocolException{
  1230.         
  1231.         boolean checkEnabled = idSoggetto!=null && idSoggetto.getNome()!=null && this.modiProperties.isValidazioneTokenPDNDProducerIdCheck(idSoggetto.getNome());
  1232.         if(!checkEnabled) {
  1233.             return true;
  1234.         }
  1235.         
  1236.         String producerIdClaimReceived = readProducerIdFromTokenOAuth();            
  1237.         if(producerIdClaimReceived!=null && StringUtils.isNotEmpty(producerIdClaimReceived)) {

  1239.             Soggetto s = null;
  1240.             try {
  1241.                 s = registryReader.getSoggetto(idSoggetto);
  1242.             }catch(Exception e) {
  1243.                 throw new ProtocolException(e.getMessage(),e);
  1244.             }
  1245.             String idEnte = ProtocolPropertiesUtils.getOptionalStringValuePropertyRegistry(s.getProtocolPropertyList(), ModICostanti.MODIPA_SOGGETTI_ID_ENTE_ID);
  1246.             if(idEnte!=null && StringUtils.isNotEmpty(idEnte) && !idEnte.equals(producerIdClaimReceived)) {
  1247.                 this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1248.                         isRichiesta ? CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_EROGATORE_NON_VALIDO :
  1249.                             CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_FRUITORE_NON_VALIDO, 
  1250.                             prefixAuthorization+getErroreClaimNonValido(org.openspcoop2.pdd.core.token.Costanti.PDND_PRODUCER_ID)));
  1251.                 return false;
  1252.             }
  1253.             
  1254.         }
  1255.         
  1256.         return true;
  1257.     }
  1258.     
  1259.     private boolean validateTokenAuthorizationServiceDescriptorIdByModIConfig(IRegistryReader registryReader, Busta busta, 
  1260.             boolean isRichiesta, String prefixAuthorization) throws ProtocolException{
  1261.         
  1262.         IDServizio idServizio = null;
  1263.         if(busta!=null && busta.getTipoServizio()!=null && busta.getServizio()!=null && busta.getVersioneServizio()!=null && busta.getTipoDestinatario()!=null && busta .getDestinatario()!=null) {
  1264.             try {
  1265.                 idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(busta.getTipoServizio(), busta.getServizio(), busta.getTipoDestinatario(), busta .getDestinatario(), busta.getVersioneServizio());
  1266.             }catch(Exception e) {
  1267.                 throw new ProtocolException(e.getMessage(),e);
  1268.             }
  1269.             AccordoServizioParteSpecifica asps = null;
  1270.             try {
  1271.                 asps = registryReader.getAccordoServizioParteSpecifica(idServizio, false);
  1272.             }catch(Exception e) {
  1273.                 throw new ProtocolException(e.getMessage(),e);
  1274.             }
  1275.             if(!validateTokenAuthorizationServiceIdByModIConfig(asps, 
  1276.                     isRichiesta, prefixAuthorization) ) {
  1277.                 return false;
  1278.             }
  1279.             if(!validateTokenAuthorizationDescriptorIdByModIConfig(asps, 
  1280.                     isRichiesta, prefixAuthorization) ) {
  1281.                 return false;
  1282.             }
  1283.         }
  1284.         
  1285.         return true;
  1286.     }
  1287.     private boolean validateTokenAuthorizationServiceIdByModIConfig(AccordoServizioParteSpecifica asps, 
  1288.             boolean isRichiesta, String prefixAuthorization) throws ProtocolException{
  1289.         
  1290.         boolean checkEnabled = asps!=null && asps.getNomeSoggettoErogatore()!=null && this.modiProperties.isValidazioneTokenPDNDEServiceIdCheck(asps.getNomeSoggettoErogatore());
  1291.         if(!checkEnabled) {
  1292.             return true;
  1293.         }
  1294.         
  1295.         String eServiceId = ProtocolPropertiesUtils.getOptionalStringValuePropertyRegistry(asps.getProtocolPropertyList(), ModICostanti.MODIPA_API_IMPL_INFO_ESERVICE_ID);
  1296.         if(eServiceId!=null && StringUtils.isNotEmpty(eServiceId)) {
  1297.             String serviceIdClaimReceived = readServiceIdFromTokenOAuth();  
  1298.             if(serviceIdClaimReceived==null || StringUtils.isEmpty(serviceIdClaimReceived)) {
  1299.                 this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1300.                         isRichiesta ? CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_EROGATORE_NON_VALIDO :
  1301.                             CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_FRUITORE_NON_VALIDO, 
  1302.                             prefixAuthorization+getErroreClaimNonPresente(org.openspcoop2.pdd.core.token.Costanti.PDND_SERVICE_ID)));
  1303.                 return false;
  1304.             }
  1305.             if(!serviceIdClaimReceived.equals(eServiceId)) {
  1306.                 this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1307.                         isRichiesta ? CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_EROGATORE_NON_VALIDO :
  1308.                             CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_FRUITORE_NON_VALIDO, 
  1309.                             prefixAuthorization+getErroreClaimNonValido(org.openspcoop2.pdd.core.token.Costanti.PDND_SERVICE_ID)));
  1310.                 return false;
  1311.             }
  1312.         }
  1313.         return true;
  1314.     }
  1315.     private boolean validateTokenAuthorizationDescriptorIdByModIConfig(AccordoServizioParteSpecifica asps, 
  1316.             boolean isRichiesta, String prefixAuthorization) throws ProtocolException{
  1317.         
  1318.         boolean checkEnabled = asps!=null && asps.getNomeSoggettoErogatore()!=null && this.modiProperties.isValidazioneTokenPDNDDescriptorIdCheck(asps.getNomeSoggettoErogatore());
  1319.         if(!checkEnabled) {
  1320.             return true;
  1321.         }
  1322.         
  1323.         String tmpDescriptorId = ProtocolPropertiesUtils.getOptionalStringValuePropertyRegistry(asps.getProtocolPropertyList(), ModICostanti.MODIPA_API_IMPL_INFO_DESCRIPTOR_ID);
  1324.         List<String> descriptorIdList = null;
  1325.         if(tmpDescriptorId!=null && StringUtils.isNotEmpty(tmpDescriptorId)) {
  1326.             descriptorIdList = ModISecurityConfig.convertToList(tmpDescriptorId);
  1327.         }
  1328.         if(descriptorIdList!=null && !descriptorIdList.isEmpty()) {
  1329.             return validateTokenAuthorizationDescriptorIdByModIConfig(descriptorIdList,
  1330.                     isRichiesta, prefixAuthorization);
  1331.         }
  1332.         return true;
  1333.     }
  1334.     private boolean validateTokenAuthorizationDescriptorIdByModIConfig(List<String> descriptorIdList,
  1335.             boolean isRichiesta, String prefixAuthorization) throws ProtocolException{
  1336.         String descriptorIdClaimReceived = readDescriptorIdFromTokenOAuth();    
  1337.         if(descriptorIdClaimReceived==null || StringUtils.isEmpty(descriptorIdClaimReceived)) {
  1338.             this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1339.                     isRichiesta ? CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_EROGATORE_NON_VALIDO :
  1340.                         CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_FRUITORE_NON_VALIDO, 
  1341.                         prefixAuthorization+getErroreClaimNonPresente(org.openspcoop2.pdd.core.token.Costanti.PDND_DESCRIPTOR_ID)));
  1342.             return false;
  1343.         }
  1344.         if(!descriptorIdList.contains(descriptorIdClaimReceived)) {
  1345.             this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1346.                     isRichiesta ? CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_EROGATORE_NON_VALIDO :
  1347.                         CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_FRUITORE_NON_VALIDO, 
  1348.                         prefixAuthorization+getErroreClaimNonValido(org.openspcoop2.pdd.core.token.Costanti.PDND_DESCRIPTOR_ID)));
  1349.             return false;
  1350.         }
  1351.         return true;
  1352.     }
  1353.     
  1354.     private PortaApplicativa readPortaApplicativa(OpenSPCoop2Message msg, IProtocolFactory<?> factory, IState state, RequestInfo requestInfo) throws ProtocolException {
  1355.         
  1356.         PortaApplicativa pa = null;
  1357.         String interfaceName = null;
  1358.         if(msg!=null && msg.getTransportRequestContext()!=null && msg.getTransportRequestContext().getInterfaceName()!=null) {
  1359.             interfaceName = msg.getTransportRequestContext().getInterfaceName();
  1360.         }
  1361.         else if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  1362.             interfaceName = requestInfo.getProtocolContext().getInterfaceName();
  1363.         }
  1364.         if(interfaceName==null) {
  1365.             throw new ProtocolException("ID Porta non presente");
  1366.         }
  1367.         IDPortaApplicativa idPA = new IDPortaApplicativa();
  1368.         idPA.setNome(interfaceName);
  1369.         try {
  1370.             pa = factory.getCachedConfigIntegrationReader(state, requestInfo).getPortaApplicativa(idPA); // pa invocata
  1371.         }catch(Exception e) {
  1372.             throw new ProtocolException(e.getMessage(),e);
  1373.         }
  1374.         
  1375.         return pa;
  1376.         
  1377.     }
  1378.     private PortaApplicativa readPortaApplicativaDefault(OpenSPCoop2Message msg, IProtocolFactory<?> factory, IState state, RequestInfo requestInfo) throws ProtocolException {
  1379.         PortaApplicativa paDefault = null;
  1380.         if(msg!=null) {
  1381.             Object nomePortaInvocataObject = msg.getContextProperty(CostantiPdD.NOME_PORTA_INVOCATA);
  1382.             String nomePorta = null;
  1383.             if(nomePortaInvocataObject instanceof String) {
  1384.                 nomePorta = (String) nomePortaInvocataObject;
  1385.             }
  1386.             if(nomePorta==null && this.context!=null && this.context.containsKey(CostantiPdD.NOME_PORTA_INVOCATA)) {
  1387.                 nomePorta = (String) this.context.getObject(CostantiPdD.NOME_PORTA_INVOCATA);
  1388.             }
  1389.             if(nomePorta==null && requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  1390.                 nomePorta = requestInfo.getProtocolContext().getInterfaceName(); // se non e' presente 'NOME_PORTA_INVOCATA' significa che non e' stato invocato un gruppo specifico
  1391.             }
  1392.             if(nomePorta!=null) {
  1393.                 IDPortaApplicativa idPA = new IDPortaApplicativa();
  1394.                 idPA.setNome(nomePorta);
  1395.                 try {
  1396.                     paDefault = factory.getCachedConfigIntegrationReader(state, requestInfo).getPortaApplicativa(idPA);
  1397.                 }catch(Exception e) {
  1398.                     throw new ProtocolException(e.getMessage(),e);
  1399.                 }
  1400.             }
  1401.             else {
  1402.                 throw new ProtocolException("ID Porta 'default' non presente");
  1403.             }
  1404.         }
  1405.         return paDefault;
  1406.     }
  1407.     private boolean isAudienceCheckDefinedInAuthorizationTokenClaims(PortaApplicativa pa) throws ProtocolException {
  1408.         
  1409.         boolean audienceCheckDefinedInAuthorizationTokenClaims = false;
  1410.     
  1411.         if(pa.getGestioneToken()!=null && pa.getGestioneToken().getOptions()!=null) {
  1412.             SortedMap<List<String>> properties = null;
  1413.             try {
  1414.                 properties = PropertiesUtilities.convertTextToSortedListMap(pa.getGestioneToken().getOptions());
  1415.             }catch(Exception e) {
  1416.                 throw new ProtocolException(e.getMessage(),e);
  1417.             }
  1418.             if(properties!=null && properties.size()>0 && properties.containsKey(Claims.JSON_WEB_TOKEN_RFC_7519_AUDIENCE)) {
  1419.                 audienceCheckDefinedInAuthorizationTokenClaims = true; // la verifica viene fatta nell'autorizzazione per token claims                  
  1420.             }
  1421.         }
  1422.         
  1423.         return audienceCheckDefinedInAuthorizationTokenClaims;
  1424.     }
  1425.     private List<String> readAudienceFromTokenOAuth() {
  1426.         Object oInformazioniTokenNormalizzate = null;
  1427.         if(this.context!=null) {
  1428.             oInformazioniTokenNormalizzate = this.context.getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_INFORMAZIONI_NORMALIZZATE);
  1429.         }
  1430.         InformazioniToken informazioniTokenNormalizzate = null;
  1431.         List<String> audienceClaimReceived = null;
  1432.         if(oInformazioniTokenNormalizzate!=null) {
  1433.             informazioniTokenNormalizzate = (InformazioniToken) oInformazioniTokenNormalizzate;
  1434.             audienceClaimReceived = informazioniTokenNormalizzate.getAud();
  1435.         }
  1436.         return audienceClaimReceived;
  1437.     }
  1438.     private void checkAudienceModIConfig(OpenSPCoop2Message msg, IProtocolFactory<?> factory, IState state, RequestInfo requestInfo,
  1439.             boolean isRichiesta, String prefixAuthorization,
  1440.             List<String> audienceClaimReceived) throws ProtocolException {
  1441.         PortaApplicativa paDefault = readPortaApplicativaDefault(msg, factory, state, requestInfo);
  1442.         
  1443.         /**System.out.println("VERIFICO RISPETTO AL VALORE ATTESO '"+modISecurityConfig.getAudience()+"'");*/
  1444.         
  1445.         checkAudienceModIConfig(msg, state, requestInfo,
  1446.                 isRichiesta, prefixAuthorization,
  1447.                 paDefault,
  1448.                 audienceClaimReceived);
  1449.     }
  1450.     private void checkAudienceModIConfig(OpenSPCoop2Message msg, IState state, RequestInfo requestInfo,
  1451.             boolean isRichiesta, String prefixAuthorization,
  1452.             PortaApplicativa paDefault,
  1453.             List<String> audienceClaimReceived) throws ProtocolException {
  1454.         ModISecurityConfig modISecurityConfig = new ModISecurityConfig(msg, this.protocolFactory, state,requestInfo, 
  1455.                 !isRichiesta, // fruizione, 
  1456.                 isRichiesta, // request,
  1457.                 paDefault);
  1458.         
  1459.         boolean find = false;
  1460.         for (String claim : audienceClaimReceived) {
  1461.             if(claim.equalsIgnoreCase(modISecurityConfig.getAudience())) {
  1462.                 find = true;
  1463.                 break;
  1464.             }   
  1465.         }
  1466.         if(!find) {
  1467.             this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1468.                     isRichiesta ? CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_EROGATORE_NON_VALIDO :
  1469.                         CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_FRUITORE_NON_VALIDO, 
  1470.                         prefixAuthorization+getErroreClaimNonValido(Claims.JSON_WEB_TOKEN_RFC_7519_AUDIENCE)));
  1471.         }
  1472.     }
  1473.     
  1474.     private String readProducerIdFromTokenOAuth() {
  1475.         return readClaimFromTokenOAuth(org.openspcoop2.pdd.core.token.Costanti.PDND_PRODUCER_ID);
  1476.     }
  1477.     private String readServiceIdFromTokenOAuth() {
  1478.         return readClaimFromTokenOAuth(org.openspcoop2.pdd.core.token.Costanti.PDND_SERVICE_ID);
  1479.     }
  1480.     private String readDescriptorIdFromTokenOAuth() {
  1481.         return readClaimFromTokenOAuth(org.openspcoop2.pdd.core.token.Costanti.PDND_DESCRIPTOR_ID);
  1482.     }
  1483.     private String readClaimFromTokenOAuth(String name) {
  1484.         Object oInformazioniTokenNormalizzate = null;
  1485.         if(this.context!=null) {
  1486.             oInformazioniTokenNormalizzate = this.context.getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_INFORMAZIONI_NORMALIZZATE);
  1487.         }
  1488.         InformazioniToken informazioniTokenNormalizzate = null;
  1489.         if(oInformazioniTokenNormalizzate!=null) {
  1490.             informazioniTokenNormalizzate = (InformazioniToken) oInformazioniTokenNormalizzate;
  1491.             if(informazioniTokenNormalizzate.getClaims()!=null) {
  1492.                 Serializable s = informazioniTokenNormalizzate.getClaims().get(name);
  1493.                 if(s instanceof String) {
  1494.                     return (String) s;
  1495.                 }
  1496.             }
  1497.         }
  1498.         return null;
  1499.     }
  1500. }
Created with JaCoCo 0.8.8.202204050719