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.IDServizioApplicativo;
  42. import org.openspcoop2.core.id.IDSoggetto;
  43. import org.openspcoop2.core.registry.Soggetto;
  44. import org.openspcoop2.message.OpenSPCoop2Message;
  45. import org.openspcoop2.message.constants.ServiceBinding;
  46. import org.openspcoop2.pdd.config.ConfigurazionePdDReader;
  47. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  48. import org.openspcoop2.pdd.config.PDNDResolver;
  49. import org.openspcoop2.pdd.core.CostantiPdD;
  50. import org.openspcoop2.pdd.core.token.InformazioniToken;
  51. import org.openspcoop2.pdd.core.token.TokenUtilities;
  52. import org.openspcoop2.pdd.core.token.parser.Claims;
  53. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  54. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  55. import org.openspcoop2.protocol.basic.validator.ValidazioneSemantica;
  56. import org.openspcoop2.protocol.engine.SecurityTokenUtilities;
  57. import org.openspcoop2.protocol.modipa.config.ModIProperties;
  58. import org.openspcoop2.protocol.modipa.constants.ModICostanti;
  59. import org.openspcoop2.protocol.modipa.utils.ModISecurityConfig;
  60. import org.openspcoop2.protocol.modipa.utils.ModIUtilities;
  61. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  62. import org.openspcoop2.protocol.sdk.Busta;
  63. import org.openspcoop2.protocol.sdk.Eccezione;
  64. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  65. import org.openspcoop2.protocol.sdk.ProtocolException;
  66. import org.openspcoop2.protocol.sdk.RestMessageSecurityToken;
  67. import org.openspcoop2.protocol.sdk.SecurityToken;
  68. import org.openspcoop2.protocol.sdk.constants.CodiceErroreCooperazione;
  69. import org.openspcoop2.protocol.sdk.constants.RuoloBusta;
  70. import org.openspcoop2.protocol.sdk.properties.ProtocolPropertiesUtils;
  71. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  72. import org.openspcoop2.protocol.sdk.state.IState;
  73. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  74. import org.openspcoop2.protocol.sdk.validator.ProprietaValidazione;
  75. import org.openspcoop2.protocol.sdk.validator.ValidazioneSemanticaResult;
  76. import org.openspcoop2.protocol.sdk.validator.ValidazioneUtils;
  77. import org.openspcoop2.protocol.utils.ModIUtils;
  78. import org.openspcoop2.protocol.utils.ModIValidazioneSemanticaProfiloSicurezza;
  79. import org.openspcoop2.utils.SortedMap;
  80. import org.openspcoop2.utils.certificate.remote.RemoteStoreConfig;
  81. import org.openspcoop2.utils.date.DateManager;
  82. import org.openspcoop2.utils.date.DateUtils;
  83. import org.openspcoop2.utils.digest.DigestEncoding;
  84. import org.openspcoop2.utils.properties.PropertiesUtilities;
  85. import org.openspcoop2.utils.transport.http.HttpConstants;



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

  97. public class ModIValidazioneSemantica extends ValidazioneSemantica {

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

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

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

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

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

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

  1226.             Soggetto s = null;
  1227.             try {
  1228.                 s = registriReader.getSoggetto(idSoggetto);
  1229.             }catch(Exception e) {
  1230.                 throw new ProtocolException(e.getMessage(),e);
  1231.             }
  1232.             String idEnte = ProtocolPropertiesUtils.getOptionalStringValuePropertyRegistry(s.getProtocolPropertyList(), ModICostanti.MODIPA_SOGGETTI_ID_ENTE_ID);
  1233.             if(idEnte!=null && StringUtils.isNotEmpty(idEnte) && !idEnte.equals(producerIdClaimReceived)) {
  1234.                 this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1235.                         isRichiesta ? CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_EROGATORE_NON_VALIDO :
  1236.                             CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_FRUITORE_NON_VALIDO, 
  1237.                             prefixAuthorization+getErroreClaimNonValido(org.openspcoop2.pdd.core.token.Costanti.PDND_PRODUCER_ID)));
  1238.                 return false;
  1239.             }
  1240.             
  1241.         }
  1242.         
  1243.         return true;
  1244.     }
  1245.     
  1246.     private PortaApplicativa readPortaApplicativa(OpenSPCoop2Message msg, IProtocolFactory<?> factory, IState state, RequestInfo requestInfo) throws ProtocolException {
  1247.         
  1248.         PortaApplicativa pa = null;
  1249.         String interfaceName = null;
  1250.         if(msg!=null && msg.getTransportRequestContext()!=null && msg.getTransportRequestContext().getInterfaceName()!=null) {
  1251.             interfaceName = msg.getTransportRequestContext().getInterfaceName();
  1252.         }
  1253.         else if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  1254.             interfaceName = requestInfo.getProtocolContext().getInterfaceName();
  1255.         }
  1256.         if(interfaceName==null) {
  1257.             throw new ProtocolException("ID Porta non presente");
  1258.         }
  1259.         IDPortaApplicativa idPA = new IDPortaApplicativa();
  1260.         idPA.setNome(interfaceName);
  1261.         try {
  1262.             pa = factory.getCachedConfigIntegrationReader(state, requestInfo).getPortaApplicativa(idPA); // pa invocata
  1263.         }catch(Exception e) {
  1264.             throw new ProtocolException(e.getMessage(),e);
  1265.         }
  1266.         
  1267.         return pa;
  1268.         
  1269.     }
  1270.     private PortaApplicativa readPortaApplicativaDefault(OpenSPCoop2Message msg, IProtocolFactory<?> factory, IState state, RequestInfo requestInfo) throws ProtocolException {
  1271.         PortaApplicativa paDefault = null;
  1272.         if(msg!=null) {
  1273.             Object nomePortaInvocataObject = msg.getContextProperty(CostantiPdD.NOME_PORTA_INVOCATA);
  1274.             String nomePorta = null;
  1275.             if(nomePortaInvocataObject instanceof String) {
  1276.                 nomePorta = (String) nomePortaInvocataObject;
  1277.             }
  1278.             if(nomePorta==null && this.context!=null && this.context.containsKey(CostantiPdD.NOME_PORTA_INVOCATA)) {
  1279.                 nomePorta = (String) this.context.getObject(CostantiPdD.NOME_PORTA_INVOCATA);
  1280.             }
  1281.             if(nomePorta==null && requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  1282.                 nomePorta = requestInfo.getProtocolContext().getInterfaceName(); // se non e' presente 'NOME_PORTA_INVOCATA' significa che non e' stato invocato un gruppo specifico
  1283.             }
  1284.             if(nomePorta!=null) {
  1285.                 IDPortaApplicativa idPA = new IDPortaApplicativa();
  1286.                 idPA.setNome(nomePorta);
  1287.                 try {
  1288.                     paDefault = factory.getCachedConfigIntegrationReader(state, requestInfo).getPortaApplicativa(idPA);
  1289.                 }catch(Exception e) {
  1290.                     throw new ProtocolException(e.getMessage(),e);
  1291.                 }
  1292.             }
  1293.             else {
  1294.                 throw new ProtocolException("ID Porta 'default' non presente");
  1295.             }
  1296.         }
  1297.         return paDefault;
  1298.     }
  1299.     private boolean isAudienceCheckDefinedInAuthorizationTokenClaims(PortaApplicativa pa) throws ProtocolException {
  1300.         
  1301.         boolean audienceCheckDefinedInAuthorizationTokenClaims = false;
  1302.     
  1303.         if(pa.getGestioneToken()!=null && pa.getGestioneToken().getOptions()!=null) {
  1304.             SortedMap<List<String>> properties = null;
  1305.             try {
  1306.                 properties = PropertiesUtilities.convertTextToSortedListMap(pa.getGestioneToken().getOptions());
  1307.             }catch(Exception e) {
  1308.                 throw new ProtocolException(e.getMessage(),e);
  1309.             }
  1310.             if(properties!=null && properties.size()>0 && properties.containsKey(Claims.JSON_WEB_TOKEN_RFC_7519_AUDIENCE)) {
  1311.                 audienceCheckDefinedInAuthorizationTokenClaims = true; // la verifica viene fatta nell'autorizzazione per token claims                  
  1312.             }
  1313.         }
  1314.         
  1315.         return audienceCheckDefinedInAuthorizationTokenClaims;
  1316.     }
  1317.     private List<String> readAudienceFromTokenOAuth() {
  1318.         Object oInformazioniTokenNormalizzate = null;
  1319.         if(this.context!=null) {
  1320.             oInformazioniTokenNormalizzate = this.context.getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_INFORMAZIONI_NORMALIZZATE);
  1321.         }
  1322.         InformazioniToken informazioniTokenNormalizzate = null;
  1323.         List<String> audienceClaimReceived = null;
  1324.         if(oInformazioniTokenNormalizzate!=null) {
  1325.             informazioniTokenNormalizzate = (InformazioniToken) oInformazioniTokenNormalizzate;
  1326.             audienceClaimReceived = informazioniTokenNormalizzate.getAud();
  1327.         }
  1328.         return audienceClaimReceived;
  1329.     }
  1330.     private void checkAudienceModIConfig(OpenSPCoop2Message msg, IProtocolFactory<?> factory, IState state, RequestInfo requestInfo,
  1331.             boolean isRichiesta, String prefixAuthorization,
  1332.             List<String> audienceClaimReceived) throws ProtocolException {
  1333.         PortaApplicativa paDefault = readPortaApplicativaDefault(msg, factory, state, requestInfo);
  1334.         
  1335.         /**System.out.println("VERIFICO RISPETTO AL VALORE ATTESO '"+modISecurityConfig.getAudience()+"'");*/
  1336.         
  1337.         checkAudienceModIConfig(msg, state, requestInfo,
  1338.                 isRichiesta, prefixAuthorization,
  1339.                 paDefault,
  1340.                 audienceClaimReceived);
  1341.     }
  1342.     private void checkAudienceModIConfig(OpenSPCoop2Message msg, IState state, RequestInfo requestInfo,
  1343.             boolean isRichiesta, String prefixAuthorization,
  1344.             PortaApplicativa paDefault,
  1345.             List<String> audienceClaimReceived) throws ProtocolException {
  1346.         ModISecurityConfig modISecurityConfig = new ModISecurityConfig(msg, this.protocolFactory, state,requestInfo, 
  1347.                 !isRichiesta, // fruizione, 
  1348.                 isRichiesta, // request,
  1349.                 paDefault);
  1350.         
  1351.         boolean find = false;
  1352.         for (String claim : audienceClaimReceived) {
  1353.             if(claim.equalsIgnoreCase(modISecurityConfig.getAudience())) {
  1354.                 find = true;
  1355.                 break;
  1356.             }   
  1357.         }
  1358.         if(!find) {
  1359.             this.erroriValidazione.add(this.validazioneUtils.newEccezioneValidazione(
  1360.                     isRichiesta ? CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_EROGATORE_NON_VALIDO :
  1361.                         CodiceErroreCooperazione.SERVIZIO_APPLICATIVO_FRUITORE_NON_VALIDO, 
  1362.                         prefixAuthorization+getErroreClaimNonValido(Claims.JSON_WEB_TOKEN_RFC_7519_AUDIENCE)));
  1363.         }
  1364.     }
  1365.     
  1366.     private String readProducerIdFromTokenOAuth() {
  1367.         return readClaimFromTokenOAuth(org.openspcoop2.pdd.core.token.Costanti.PDND_PRODUCER_ID);
  1368.     }
  1369.     private String readClaimFromTokenOAuth(String name) {
  1370.         Object oInformazioniTokenNormalizzate = null;
  1371.         if(this.context!=null) {
  1372.             oInformazioniTokenNormalizzate = this.context.getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_INFORMAZIONI_NORMALIZZATE);
  1373.         }
  1374.         InformazioniToken informazioniTokenNormalizzate = null;
  1375.         if(oInformazioniTokenNormalizzate!=null) {
  1376.             informazioniTokenNormalizzate = (InformazioniToken) oInformazioniTokenNormalizzate;
  1377.             if(informazioniTokenNormalizzate.getClaims()!=null) {
  1378.                 Serializable s = informazioniTokenNormalizzate.getClaims().get(name);
  1379.                 if(s instanceof String) {
  1380.                     return (String) s;
  1381.                 }
  1382.             }
  1383.         }
  1384.         return null;
  1385.     }
  1386. }
Created with JaCoCo 0.8.8.202204050719