GestoreTokenValidazioneUtilities.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.  */
  20. package org.openspcoop2.pdd.core.token;

  22. import java.io.ByteArrayOutputStream;
  23. import java.io.Serializable;
  24. import java.text.SimpleDateFormat;
  25. import java.util.ArrayList;
  26. import java.util.Date;
  27. import java.util.Enumeration;
  28. import java.util.HashMap;
  29. import java.util.List;
  30. import java.util.Map;
  31. import java.util.Properties;

  33. import org.apache.commons.lang.StringUtils;
  34. import org.apache.cxf.rs.security.jose.jwk.JsonWebKeys;
  35. import org.openspcoop2.core.commons.CoreException;
  36. import org.openspcoop2.core.commons.DBUtils;
  37. import org.openspcoop2.core.config.InvocazioneCredenziali;
  38. import org.openspcoop2.core.config.PortaApplicativa;
  39. import org.openspcoop2.core.config.PortaDelegata;
  40. import org.openspcoop2.core.config.Proprieta;
  41. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  42. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  43. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  44. import org.openspcoop2.core.constants.CostantiConnettori;
  45. import org.openspcoop2.core.constants.CostantiLabel;
  46. import org.openspcoop2.core.constants.TipiConnettore;
  47. import org.openspcoop2.core.constants.TransferLengthModes;
  48. import org.openspcoop2.core.id.IDServizio;
  49. import org.openspcoop2.core.id.IDSoggetto;
  50. import org.openspcoop2.message.OpenSPCoop2Message;
  51. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  52. import org.openspcoop2.message.OpenSPCoop2MessageParseResult;
  53. import org.openspcoop2.message.constants.MessageType;
  54. import org.openspcoop2.message.rest.OpenSPCoop2Message_binary_impl;
  55. import org.openspcoop2.message.utils.WWWAuthenticateErrorCode;
  56. import org.openspcoop2.message.utils.WWWAuthenticateGenerator;
  57. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  58. import org.openspcoop2.pdd.config.CostantiProprieta;
  59. import org.openspcoop2.pdd.config.ForwardProxy;
  60. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  61. import org.openspcoop2.pdd.config.PDNDResolver;
  62. import org.openspcoop2.pdd.core.CostantiPdD;
  63. import org.openspcoop2.pdd.core.PdDContext;
  64. import org.openspcoop2.pdd.core.connettori.ConnettoreBaseHTTP;
  65. import org.openspcoop2.pdd.core.connettori.ConnettoreHTTP;
  66. import org.openspcoop2.pdd.core.connettori.ConnettoreHTTPS;
  67. import org.openspcoop2.pdd.core.connettori.ConnettoreMsg;
  68. import org.openspcoop2.pdd.core.controllo_traffico.PolicyTimeoutConfig;
  69. import org.openspcoop2.pdd.core.dynamic.DynamicException;
  70. import org.openspcoop2.pdd.core.dynamic.DynamicUtils;
  71. import org.openspcoop2.pdd.core.token.pa.DatiInvocazionePortaApplicativa;
  72. import org.openspcoop2.pdd.core.token.pa.EsitoDynamicDiscoveryPortaApplicativa;
  73. import org.openspcoop2.pdd.core.token.pa.EsitoGestioneTokenPortaApplicativa;
  74. import org.openspcoop2.pdd.core.token.parser.Claims;
  75. import org.openspcoop2.pdd.core.token.parser.IDynamicDiscoveryParser;
  76. import org.openspcoop2.pdd.core.token.parser.ITokenParser;
  77. import org.openspcoop2.pdd.core.token.pd.DatiInvocazionePortaDelegata;
  78. import org.openspcoop2.pdd.core.token.pd.EsitoDynamicDiscoveryPortaDelegata;
  79. import org.openspcoop2.pdd.core.token.pd.EsitoGestioneTokenPortaDelegata;
  80. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  81. import org.openspcoop2.protocol.sdk.Busta;
  82. import org.openspcoop2.protocol.sdk.Context;
  83. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  84. import org.openspcoop2.protocol.sdk.PDNDTokenInfo;
  85. import org.openspcoop2.protocol.sdk.ProtocolException;
  86. import org.openspcoop2.protocol.sdk.RestMessageSecurityToken;
  87. import org.openspcoop2.protocol.sdk.SecurityToken;
  88. import org.openspcoop2.protocol.sdk.state.IState;
  89. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  90. import org.openspcoop2.protocol.utils.ModIUtils;
  91. import org.openspcoop2.security.SecurityException;
  92. import org.openspcoop2.security.keystore.CRLCertstore;
  93. import org.openspcoop2.security.keystore.cache.GestoreKeystoreCache;
  94. import org.openspcoop2.security.keystore.cache.GestoreOCSPResource;
  95. import org.openspcoop2.security.keystore.cache.GestoreOCSPValidator;
  96. import org.openspcoop2.security.message.constants.SecurityConstants;
  97. import org.openspcoop2.utils.BooleanNullable;
  98. import org.openspcoop2.utils.LoggerBuffer;
  99. import org.openspcoop2.utils.UtilsException;
  100. import org.openspcoop2.utils.certificate.CertificateInfo;
  101. import org.openspcoop2.utils.certificate.JWKSet;
  102. import org.openspcoop2.utils.certificate.remote.RemoteStoreConfig;
  103. import org.openspcoop2.utils.date.DateManager;
  104. import org.openspcoop2.utils.date.DateUtils;
  105. import org.openspcoop2.utils.io.Base64Utilities;
  106. import org.openspcoop2.utils.json.JSONUtils;
  107. import org.openspcoop2.utils.security.CertificateValidityCheck;
  108. import org.openspcoop2.utils.security.JOSESerialization;
  109. import org.openspcoop2.utils.security.JWEOptions;
  110. import org.openspcoop2.utils.security.JWSOptions;
  111. import org.openspcoop2.utils.security.JWTOptions;
  112. import org.openspcoop2.utils.security.JsonDecrypt;
  113. import org.openspcoop2.utils.security.JsonEncrypt;
  114. import org.openspcoop2.utils.security.JsonSignature;
  115. import org.openspcoop2.utils.security.JsonVerifySignature;
  116. import org.openspcoop2.utils.transport.TransportRequestContext;
  117. import org.openspcoop2.utils.transport.TransportUtils;
  118. import org.openspcoop2.utils.transport.http.HttpConstants;
  119. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  120. import org.openspcoop2.utils.transport.http.HttpResponse;
  121. import org.openspcoop2.utils.transport.http.IOCSPValidator;
  122. import org.slf4j.Logger;

  124. import com.fasterxml.jackson.databind.JsonNode;
  125. import com.fasterxml.jackson.databind.node.ArrayNode;
  126. import com.fasterxml.jackson.databind.node.ObjectNode;

  128. /**     
  129.  * GestoreTokenValidazioneUtilities
  130.  *
  131.  * @author Poli Andrea (poli@link.it)
  132.  * @author $Author$
  133.  * @version $Rev$, $Date$
  134.  */
  135. public class GestoreTokenValidazioneUtilities {

  137.     private GestoreTokenValidazioneUtilities() {}
  138.     
  139.     private static final String PREFIX_ERROR_CONNESSIONE = "(Errore di Connessione) ";
  140.     
  141.     
  142.     
  143.     // ********* [VALIDAZIONE-TOKEN] DYNAMIC DISCOVERY ****************** */
  144.         
  145.     static EsitoDynamicDiscovery dynamicDiscoveryEngine(Logger log, AbstractDatiInvocazione datiInvocazione, 
  146.             PdDContext pddContext, IProtocolFactory<?> protocolFactory,
  147.             String token, boolean portaDelegata,
  148.             Busta busta, IDSoggetto idDominio, IDServizio idServizio) {
  149.         
  150.         
  151.         EsitoDynamicDiscovery esitoGestioneToken = null;
  152.         if(portaDelegata) {
  153.             esitoGestioneToken = new EsitoDynamicDiscoveryPortaDelegata();
  154.         }
  155.         else {
  156.             esitoGestioneToken = new EsitoDynamicDiscoveryPortaApplicativa();
  157.         }
  158.         
  159.         esitoGestioneToken.setTokenInternalError();
  160.         esitoGestioneToken.setToken(token);
  161.         
  162.         try{
  163.             PolicyGestioneToken policyGestioneToken = datiInvocazione.getPolicyGestioneToken();
  164.             
  165.             String detailsError = null;
  166.             DynamicDiscovery dd = null;
  167.             Exception eProcess = null;
  168.             
  169.             IDynamicDiscoveryParser ddParser = policyGestioneToken.getDynamicDiscoveryParser();
  170.             
  171.             PortaApplicativa pa = null;
  172.             PortaDelegata pd = null;
  173.             if(datiInvocazione instanceof DatiInvocazionePortaApplicativa) {
  174.                 pa = ((DatiInvocazionePortaApplicativa)datiInvocazione).getPa();
  175.             }
  176.             else if(datiInvocazione instanceof DatiInvocazionePortaDelegata) {
  177.                 pd = ((DatiInvocazionePortaDelegata)datiInvocazione).getPd();
  178.             }
  179.             
  180.             HttpResponse httpResponse = null;
  181.             Integer httpResponseCode = null;
  182.             byte[] risposta = null;
  183.             try {
  184.                 httpResponse = GestoreTokenValidazioneUtilities.http(log, policyGestioneToken, HTTP_TYPE.DYNAMIC_DISCOVERY, 
  185.                         null, token,
  186.                         pddContext, protocolFactory,
  187.                         datiInvocazione.getState(), portaDelegata, datiInvocazione.getIdModulo(), pa, pd,
  188.                         idDominio, idServizio,
  189.                         busta, datiInvocazione.getRequestInfo());
  190.                 risposta = httpResponse.getContent();
  191.                 httpResponseCode = httpResponse.getResultHTTPOperation();
  192.             }catch(Exception e) {
  193.                 detailsError = PREFIX_ERROR_CONNESSIONE+ e.getMessage();
  194.                 eProcess = e;
  195.             }
  196.             
  197.             if(detailsError==null) {
  198.                 try {
  199.                     dd = new DynamicDiscovery(httpResponseCode, policyGestioneToken.getDynamicDiscoveryType(), new String(risposta),ddParser);
  200.                 }catch(Exception e) {
  201.                     detailsError = "Risposta del servizio 'Dynamic Discovery' non valida: "+e.getMessage();
  202.                     eProcess = e;
  203.                 }
  204.             }
  205.                     
  206.             if(dd!=null && dd.isValid()) {
  207.                 esitoGestioneToken.setTokenValido();
  208.                 esitoGestioneToken.setDynamicDiscovery(dd);
  209.                 esitoGestioneToken.setNoCache(false);
  210.             }
  211.             else {
  212.                 esitoGestioneToken.setTokenValidazioneFallita();
  213.                 esitoGestioneToken.setNoCache(!policyGestioneToken.isIntrospectionSaveErrorInCache());
  214.                 esitoGestioneToken.setEccezioneProcessamento(eProcess);
  215.                 if(detailsError!=null) {
  216.                     esitoGestioneToken.setDetails(detailsError);    
  217.                 }
  218.                 else {
  219.                     esitoGestioneToken.setDetails(GestoreToken.TOKEN_NON_VALIDO);   
  220.                 }
  221.                 
  222.                 // comunque lo aggiungo per essere consultabile nei casi di errore se una connessione http è terminata
  223.                 if(OpenSPCoop2Properties.getInstance().isGestioneTokenSaveSourceTokenInfo() && httpResponseCode!=null) {
  224.                     dd = new DynamicDiscovery(esitoGestioneToken.getDetails(), httpResponseCode, risposta, policyGestioneToken.getDynamicDiscoveryType());
  225.                     esitoGestioneToken.setDynamicDiscovery(dd);
  226.                 }
  227.                 
  228.                 if(policyGestioneToken.isMessageErrorGenerateEmptyMessage()) {
  229.                     esitoGestioneToken.setErrorMessage(WWWAuthenticateGenerator.buildErrorMessage(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  230.                             policyGestioneToken.isMessageErrorGenerateGenericMessage(), esitoGestioneToken.getDetails()));              
  231.                 }
  232.                 else {
  233.                     esitoGestioneToken.setWwwAuthenticateErrorHeader(WWWAuthenticateGenerator.buildHeaderValue(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  234.                             policyGestioneToken.isMessageErrorGenerateGenericMessage(), esitoGestioneToken.getDetails()));
  235.                 }   
  236.             }
  237.             
  238.         }catch(Exception e){
  239.             esitoGestioneToken.setTokenInternalError();
  240.             esitoGestioneToken.setDetails(e.getMessage());
  241.             esitoGestioneToken.setEccezioneProcessamento(e);
  242.         }
  243.         
  244.         return esitoGestioneToken;
  245.     }
  246.     
  247.     
  248.     
  249.     
  250.     
  251.     
  252.     // ********* [VALIDAZIONE-TOKEN] VALIDAZIONE JWT TOKEN ****************** */
  253.     
  254.     static EsitoGestioneToken validazioneJWTTokenEngine(Logger log, AbstractDatiInvocazione datiInvocazione, EsitoPresenzaToken esitoPresenzaToken, DynamicDiscovery dynamicDiscovery, 
  255.             String token, boolean portaDelegata, PdDContext pddContext,
  256.             Busta busta, IDSoggetto idDominio, IDServizio idServizio) {
  257.         EsitoGestioneToken esitoGestioneToken = null;
  258.         if(portaDelegata) {
  259.             esitoGestioneToken = new EsitoGestioneTokenPortaDelegata();
  260.         }
  261.         else {
  262.             esitoGestioneToken = new EsitoGestioneTokenPortaApplicativa();
  263.         }
  264.         
  265.         esitoGestioneToken.setTokenInternalError();
  266.         esitoGestioneToken.setToken(token);
  267.         
  268.         try{
  269.             PolicyGestioneToken policyGestioneToken = datiInvocazione.getPolicyGestioneToken();
  270.             String tokenType = policyGestioneToken.getTipoToken();
  271.             
  272.             String detailsError = null;
  273.             InformazioniToken informazioniToken = null;
  274.             Exception eProcess = null;
  275.             RestMessageSecurityToken restSecurityToken = null;
  276.             
  277.             ITokenParser tokenParser = policyGestioneToken.getValidazioneJWTTokenParser();
  278.             
  279.             if(Costanti.POLICY_TOKEN_TYPE_JWS.equals(tokenType)) {
  280.                 // JWS Compact              
  281.                 JsonVerifySignature jsonCompactVerify = null;
  282.                 try {
  283.                     jsonCompactVerify = getJsonVerifySignatureJWS(log, pddContext, datiInvocazione, policyGestioneToken, dynamicDiscovery, 
  284.                             busta, idDominio, idServizio,
  285.                             portaDelegata);
  286.                     
  287.                     if(jsonCompactVerify.verify(token)) {
  288.                         informazioniToken = new InformazioniToken(SorgenteInformazioniToken.JWT,jsonCompactVerify.getDecodedPayload(),tokenParser);
  289.                         if( pddContext!=null ) {
  290.                             restSecurityToken = new RestMessageSecurityToken();
  291.                             if(jsonCompactVerify.getX509Certificate()!=null) {
  292.                                 restSecurityToken.setCertificate(new CertificateInfo(jsonCompactVerify.getX509Certificate(), "access_token"));
  293.                             }
  294.                             if(jsonCompactVerify.getKid()!=null) {
  295.                                 restSecurityToken.setKid(jsonCompactVerify.getKid());
  296.                             }
  297.                             restSecurityToken.setToken(token);
  298.                             if(esitoPresenzaToken!=null) {
  299.                                 restSecurityToken.setHttpHeaderName(esitoPresenzaToken.getHeaderHttp());
  300.                                 restSecurityToken.setQueryParameterName(esitoPresenzaToken.getPropertyUrl());
  301.                                 restSecurityToken.setFormParameterName(esitoPresenzaToken.getPropertyFormBased());
  302.                             }
  303.                         }
  304.                         
  305.                         try {
  306.                             validazioneInformazioniTokenHeader(jsonCompactVerify.getDecodedHeader(), policyGestioneToken);
  307.                         }catch(Exception e) {
  308.                             informazioniToken.setValid(false);
  309.                             log.debug(GestoreToken.getMessageTokenNonValido(e),e);
  310.                             detailsError = GestoreToken.getMessageTokenNonValido(e);
  311.                             eProcess = e;
  312.                         }
  313.                     }
  314.                     else {
  315.                         detailsError = GestoreToken.TOKEN_NON_VALIDO;
  316.                     }
  317.                 }catch(Exception e) {
  318.                     log.debug(GestoreToken.getMessageTokenNonValido(e),e);
  319.                     detailsError = GestoreToken.getMessageTokenNonValido(e);
  320.                     eProcess = e;
  321.                 }
  322.             }
  323.             else {
  324.                 // JWE Compact
  325.                 JsonDecrypt jsonDecrypt = null;
  326.                 try {
  327.                     jsonDecrypt = getJsonDecrypt(log, pddContext, datiInvocazione, policyGestioneToken, dynamicDiscovery,
  328.                             busta, idDominio, idServizio,
  329.                             portaDelegata);
  330.                     jsonDecrypt.decrypt(token);
  331.                     informazioniToken = new InformazioniToken(SorgenteInformazioniToken.JWT,jsonDecrypt.getDecodedPayload(),tokenParser);
  332.                     if( pddContext!=null ) {
  333.                         restSecurityToken = new RestMessageSecurityToken();
  334.                         if(jsonDecrypt.getX509Certificate()!=null) {
  335.                             restSecurityToken.setCertificate(new CertificateInfo(jsonDecrypt.getX509Certificate(), "access_token"));
  336.                         }
  337.                         if(jsonDecrypt.getKid()!=null) {
  338.                             restSecurityToken.setKid(jsonDecrypt.getKid());
  339.                         }
  340.                         restSecurityToken.setJweDecodedPayload(jsonDecrypt.getDecodedPayload());
  341.                         restSecurityToken.setToken(token);
  342.                         if(esitoPresenzaToken!=null) {
  343.                             restSecurityToken.setHttpHeaderName(esitoPresenzaToken.getHeaderHttp());
  344.                             restSecurityToken.setQueryParameterName(esitoPresenzaToken.getPropertyUrl());
  345.                             restSecurityToken.setFormParameterName(esitoPresenzaToken.getPropertyFormBased());
  346.                         }
  347.                     }
  348.                 }catch(Exception e) {
  349.                     log.debug(GestoreToken.getMessageTokenNonValido(e),e);
  350.                     detailsError = GestoreToken.getMessageTokenNonValido(e);
  351.                     eProcess = e;
  352.                 }
  353.             }
  354.                     
  355.             if(informazioniToken!=null && informazioniToken.isValid()) {
  356.                 esitoGestioneToken.setTokenValido();
  357.                 esitoGestioneToken.setInformazioniToken(informazioniToken);
  358.                 esitoGestioneToken.setNoCache(false);
  359.                 esitoGestioneToken.setRestSecurityToken(restSecurityToken);
  360.             }
  361.             else {
  362.                 esitoGestioneToken.setTokenValidazioneFallita();
  363.                 esitoGestioneToken.setNoCache(!policyGestioneToken.isValidazioneJWTSaveErrorInCache());
  364.                 esitoGestioneToken.setEccezioneProcessamento(eProcess);
  365.                 if(detailsError!=null) {
  366.                     esitoGestioneToken.setDetails(detailsError);    
  367.                 }
  368.                 else {
  369.                     esitoGestioneToken.setDetails(GestoreToken.TOKEN_NON_VALIDO);   
  370.                 }
  371.                 
  372.                 // comunque lo aggiungo per essere consultabile nei casi di errore
  373.                 if(OpenSPCoop2Properties.getInstance().isGestioneTokenSaveTokenInfoValidationFailed()) {
  374.                     informazioniToken = new InformazioniToken(esitoGestioneToken.getDetails(), SorgenteInformazioniToken.JWT, token);
  375.                     esitoGestioneToken.setInformazioniToken(informazioniToken);
  376.                 }
  377.                 
  378.                 if(policyGestioneToken.isMessageErrorGenerateEmptyMessage()) {
  379.                     esitoGestioneToken.setErrorMessage(WWWAuthenticateGenerator.buildErrorMessage(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  380.                             policyGestioneToken.isMessageErrorGenerateGenericMessage(), esitoGestioneToken.getDetails()));              
  381.                 }
  382.                 else {
  383.                     esitoGestioneToken.setWwwAuthenticateErrorHeader(WWWAuthenticateGenerator.buildHeaderValue(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  384.                             policyGestioneToken.isMessageErrorGenerateGenericMessage(), esitoGestioneToken.getDetails()));
  385.                 }
  386.             }
  387.             
  388.         }catch(Exception e){
  389.             esitoGestioneToken.setTokenInternalError();
  390.             esitoGestioneToken.setDetails(e.getMessage());
  391.             esitoGestioneToken.setEccezioneProcessamento(e);
  392.         }
  393.         
  394.         return esitoGestioneToken;
  395.     }
  396.     
  397.     private static JsonVerifySignature getJsonVerifySignatureJWS(Logger log, Context context, AbstractDatiInvocazione datiInvocazione, PolicyGestioneToken policyGestioneToken, DynamicDiscovery dynamicDiscovery,
  398.             Busta busta, IDSoggetto idDominio, IDServizio idServizio,
  399.             boolean portaDelegata) throws TokenException, UtilsException, SecurityException {
  400.         // JWS Compact              
  401.         JsonVerifySignature jsonCompactVerify = null;

  403.         JWTOptions options = new JWTOptions(JOSESerialization.COMPACT);
  404.         Properties p = policyGestioneToken.getProperties().get(Costanti.POLICY_VALIDAZIONE_JWS_VERIFICA_PROP_REF_ID);
  405.         TokenUtilities.injectJOSEConfig(p, policyGestioneToken, dynamicDiscovery,  
  406.                 busta, idDominio, idServizio,
  407.                 context, log,
  408.                 datiInvocazione.getRequestInfo(), datiInvocazione.getState(), portaDelegata);
  409.         
  410.         // serve per leggere il keystore dalla cache
  411.         TokenKeystoreInjectUtilities inject = new TokenKeystoreInjectUtilities(log, datiInvocazione.getRequestInfo() ,
  412.                 datiInvocazione.getRequestInfo()!=null ? datiInvocazione.getRequestInfo().getProtocolFactory() : null, 
  413.                 context, datiInvocazione.getState(), busta);
  414.         if(datiInvocazione instanceof DatiInvocazionePortaApplicativa) {
  415.             DatiInvocazionePortaApplicativa dati = (DatiInvocazionePortaApplicativa) datiInvocazione;
  416.             inject.initTokenPolicyValidazioneJwt(policyGestioneToken.getName(), portaDelegata, dati.getPd(), dati.getPa(), p);
  417.         }
  418.         else {
  419.             DatiInvocazionePortaDelegata dati = (DatiInvocazionePortaDelegata) datiInvocazione;
  420.             inject.initTokenPolicyValidazioneJwt(policyGestioneToken.getName(), portaDelegata, dati.getPd(), null, p);
  421.         }
  422.         inject.inject(p);
  423.         
  424.         
  425.         String aliasMode = p.getProperty(SecurityConstants.JOSE_KEYSTORE_KEY_ALIAS+".mode"); 
  426.         if(aliasMode!=null && 
  427.                 (
  428.                         aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5C)
  429.                         ||
  430.                         aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5T256)
  431.                         ||
  432.                         aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5C_X5T256)
  433.                         ||
  434.                         aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_KID)
  435.                         ||
  436.                         aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5U)
  437.                 )
  438.             ) {
  439.             
  440.             options.setPermitUseHeaderX5C(aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5C) || aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5C_X5T256));
  441.             // se lo si vuole usare utilizzare la vecchia modalità alias special case
  442.             /**options.setPermitUseHeaderX5T(aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5T256) || aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5C_X5T256));*/
  443.             options.setPermitUseHeaderX5T_256(aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5T256) || aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5C_X5T256));
  444.             options.setPermitUseHeaderKID(aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_KID));
  445.             options.setPermitUseHeaderX5U(aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5U));
  446.                                     
  447.             if(p.containsKey(SecurityConstants.JOSE_KEYSTORE)) {
  448.                 Object oKeystore = p.get(SecurityConstants.JOSE_KEYSTORE);
  449.                 if(oKeystore instanceof java.security.KeyStore) {
  450.                     java.security.KeyStore keystore = (java.security.KeyStore) oKeystore;
  451.                     jsonCompactVerify = new JsonVerifySignature(keystore, options);
  452.                     
  453.                     CertificateValidityCheck validityCheck = OpenSPCoop2Properties.getInstance().getGestioneTokenValidityCheck();
  454.                     List<Proprieta> proprieta = null;
  455.                     if(datiInvocazione instanceof DatiInvocazionePortaApplicativa) {
  456.                         DatiInvocazionePortaApplicativa dati = (DatiInvocazionePortaApplicativa)datiInvocazione;
  457.                         if(dati.getPa()!=null) {
  458.                             proprieta = dati.getPa().getProprietaList();
  459.                         }
  460.                         else if(dati.getPd()!=null) {
  461.                             proprieta = dati.getPd().getProprietaList();
  462.                         }
  463.                     }
  464.                     else if(datiInvocazione instanceof DatiInvocazionePortaDelegata) {
  465.                         DatiInvocazionePortaDelegata dati = (DatiInvocazionePortaDelegata)datiInvocazione;
  466.                         if(dati.getPd()!=null) {
  467.                             proprieta = dati.getPd().getProprietaList();
  468.                         }
  469.                     }
  470.                     validityCheck = CostantiProprieta.getTokenValidationCertificateValidityCheck(proprieta, validityCheck);
  471.                     jsonCompactVerify.setValidityCheck(validityCheck);
  472.                     
  473.                     String signatureOCSP = policyGestioneToken.getValidazioneJWTOcspPolicy();
  474.                     String signatureCRL = policyGestioneToken.getValidazioneJWTCrl();
  475.                     
  476.                     boolean crlByOcsp = false;
  477.                     if(signatureOCSP!=null && !"".equals(signatureOCSP)) {
  478.                         LoggerBuffer lb = new LoggerBuffer();
  479.                         lb.setLogDebug(log);
  480.                         lb.setLogError(log);
  481.                         GestoreOCSPResource ocspResourceReader = new GestoreOCSPResource(datiInvocazione.getRequestInfo());
  482.                         IOCSPValidator ocspValidator = null;
  483.                         try {
  484.                             org.openspcoop2.utils.certificate.KeyStore trustStore = new org.openspcoop2.utils.certificate.KeyStore(keystore);
  485.                             ocspValidator = new GestoreOCSPValidator(datiInvocazione.getRequestInfo(), lb, 
  486.                                     trustStore,
  487.                                     signatureCRL, 
  488.                                     signatureOCSP, 
  489.                                     ocspResourceReader);
  490.                         }catch(Exception e){
  491.                             throw new TokenException("ocsp initialization (policy:'"+signatureOCSP+"') failed: "+e.getMessage(),e);
  492.                         }
  493.                         jsonCompactVerify.setOcspValidatorX509(ocspValidator);
  494.                         GestoreOCSPValidator gOcspValidator = (GestoreOCSPValidator) ocspValidator;
  495.                         if(gOcspValidator.getOcspConfig()!=null) {
  496.                             crlByOcsp = gOcspValidator.getOcspConfig().isCrl();
  497.                         }
  498.                     }
  499.                     
  500.                     if(signatureCRL!=null && !"".equals(signatureCRL) && !crlByOcsp) {
  501.                         CRLCertstore crlCertstore = GestoreKeystoreCache.getCRLCertstore(datiInvocazione.getRequestInfo(), signatureCRL);
  502.                         if(crlCertstore==null) {
  503.                             throw new TokenException("Process CRL '"+signatureCRL+"' failed");
  504.                         }
  505.                         jsonCompactVerify.setCrlX509(crlCertstore.getCertStore());
  506.                     }

  508.                 }
  509.             }
  510.             else if(p.containsKey(SecurityConstants.JOSE_KEYSTORE_JWKSET)) {
  511.                 Object oKeystore = p.get(SecurityConstants.JOSE_KEYSTORE_JWKSET);
  512.                 if(oKeystore instanceof String) {
  513.                     String keystore = (String) oKeystore;
  514.                     JsonWebKeys jwksKeystore = new JWKSet(keystore).getJsonWebKeys();
  515.                     jsonCompactVerify = new JsonVerifySignature(jwksKeystore, options);
  516.                 }
  517.             }
  518.         }
  519.                             
  520.         if(jsonCompactVerify==null &&
  521.             p.containsKey(SecurityConstants.JOSE_KEYSTORE_KEY_ALIAS)) {
  522.             String alias = p.getProperty(SecurityConstants.JOSE_KEYSTORE_KEY_ALIAS);
  523.             if(alias!=null && 
  524.                     (
  525.                             alias.equals(Costanti.POLICY_VALIDAZIONE_SPECIAL_CASE_USE_X5C)
  526.                             ||
  527.                             alias.equals(Costanti.POLICY_VALIDAZIONE_SPECIAL_CASE_USE_X5T)
  528.                             ||
  529.                             alias.equals(Costanti.POLICY_VALIDAZIONE_SPECIAL_CASE_USE_X5C_X5T)
  530.                     )
  531.                 &&
  532.                 (p.containsKey(SecurityConstants.JOSE_KEYSTORE)) // backward compatibility
  533.                 ){
  534.                 Object oKeystore = p.get(SecurityConstants.JOSE_KEYSTORE);
  535.                 if(oKeystore instanceof java.security.KeyStore) {
  536.                     java.security.KeyStore keystore = (java.security.KeyStore) oKeystore;
  537.                     options.setPermitUseHeaderX5C(alias.equals(Costanti.POLICY_VALIDAZIONE_SPECIAL_CASE_USE_X5C) || alias.equals(Costanti.POLICY_VALIDAZIONE_SPECIAL_CASE_USE_X5C_X5T));
  538.                     options.setPermitUseHeaderX5T(alias.equals(Costanti.POLICY_VALIDAZIONE_SPECIAL_CASE_USE_X5T) || alias.equals(Costanti.POLICY_VALIDAZIONE_SPECIAL_CASE_USE_X5C_X5T));
  539.                     options.setPermitUseHeaderX5T_256(alias.equals(Costanti.POLICY_VALIDAZIONE_SPECIAL_CASE_USE_X5T) || alias.equals(Costanti.POLICY_VALIDAZIONE_SPECIAL_CASE_USE_X5C_X5T));
  540.                     jsonCompactVerify = new JsonVerifySignature(keystore, options);
  541.                 }
  542.             }   
  543.         }
  544.         
  545.         if(jsonCompactVerify==null) {
  546.             jsonCompactVerify = new JsonVerifySignature(p, options);
  547.         }
  548.         
  549.         jsonCompactVerify.setJksPasswordRequired(DBUtils.isTruststoreJksPasswordRequired());
  550.         jsonCompactVerify.setPkcs12PasswordRequired(DBUtils.isTruststorePkcs12PasswordRequired());
  551.         
  552.         return jsonCompactVerify;
  553.     }
  554.     
  555.     private static JsonDecrypt getJsonDecrypt(Logger log, Context context, AbstractDatiInvocazione datiInvocazione, PolicyGestioneToken policyGestioneToken, DynamicDiscovery dynamicDiscovery,
  556.             Busta busta, IDSoggetto idDominio, IDServizio idServizio,
  557.             boolean portaDelegata) throws TokenException, UtilsException, SecurityException {
  558.         JsonDecrypt jsonDecrypt = null;
  559.         JWTOptions options = new JWTOptions(JOSESerialization.COMPACT);
  560.         Properties p = policyGestioneToken.getProperties().get(Costanti.POLICY_VALIDAZIONE_JWE_DECRYPT_PROP_REF_ID);
  561.         TokenUtilities.injectJOSEConfig(p, policyGestioneToken, dynamicDiscovery,  
  562.                 busta, idDominio, idServizio,
  563.                 context, log,
  564.                 datiInvocazione.getRequestInfo(), datiInvocazione.getState(), portaDelegata);
  565.         
  566.         // serve per leggere il keystore dalla cache
  567.         TokenKeystoreInjectUtilities inject = new TokenKeystoreInjectUtilities(log, datiInvocazione.getRequestInfo() ,
  568.                 datiInvocazione.getRequestInfo()!=null ? datiInvocazione.getRequestInfo().getProtocolFactory() : null, 
  569.                 context, datiInvocazione.getState(), busta);
  570.         if(datiInvocazione instanceof DatiInvocazionePortaApplicativa) {
  571.             DatiInvocazionePortaApplicativa dati = (DatiInvocazionePortaApplicativa) datiInvocazione;
  572.             inject.initTokenPolicyValidazioneJwt(policyGestioneToken.getName(), portaDelegata, dati.getPd(), dati.getPa(), p);
  573.         }
  574.         else {
  575.             DatiInvocazionePortaDelegata dati = (DatiInvocazionePortaDelegata) datiInvocazione;
  576.             inject.initTokenPolicyValidazioneJwt(policyGestioneToken.getName(), portaDelegata, dati.getPd(), null, p);
  577.         }
  578.         inject.inject(p);
  579.         
  580.         jsonDecrypt = new JsonDecrypt(p, options, 
  581.                 DBUtils.isKeystoreJksPasswordRequired(), 
  582.                 DBUtils.isKeystorePkcs12PasswordRequired());
  583.         
  584.         return jsonDecrypt;
  585.     }
  586.     
  587.     
  588.     
  589.     
  590.     // ********* [VALIDAZIONE-TOKEN] INTROSPECTION TOKEN ****************** */
  591.     
  592.     static EsitoGestioneToken introspectionTokenEngine(Logger log, AbstractDatiInvocazione datiInvocazione,  
  593.             PdDContext pddContext, IProtocolFactory<?> protocolFactory,
  594.             DynamicDiscovery dynamicDiscovery, 
  595.             String token, boolean portaDelegata,
  596.             Busta busta, IDSoggetto idDominio, IDServizio idServizio) {
  597.         EsitoGestioneToken esitoGestioneToken = null;
  598.         if(portaDelegata) {
  599.             esitoGestioneToken = new EsitoGestioneTokenPortaDelegata();
  600.         }
  601.         else {
  602.             esitoGestioneToken = new EsitoGestioneTokenPortaApplicativa();
  603.         }
  604.         
  605.         esitoGestioneToken.setTokenInternalError();
  606.         esitoGestioneToken.setToken(token);
  607.         
  608.         try{
  609.             PolicyGestioneToken policyGestioneToken = datiInvocazione.getPolicyGestioneToken();
  610.             
  611.             String detailsError = null;
  612.             InformazioniToken informazioniToken = null;
  613.             Exception eProcess = null;
  614.             
  615.             ITokenParser tokenParser = policyGestioneToken.getIntrospectionTokenParser();
  616.             
  617.             PortaApplicativa pa = null;
  618.             PortaDelegata pd = null;
  619.             if(datiInvocazione instanceof DatiInvocazionePortaApplicativa) {
  620.                 pa = ((DatiInvocazionePortaApplicativa)datiInvocazione).getPa();
  621.             }
  622.             else if(datiInvocazione instanceof DatiInvocazionePortaDelegata) {
  623.                 pd = ((DatiInvocazionePortaDelegata)datiInvocazione).getPd();
  624.             }
  625.             
  626.             HttpResponse httpResponse = null;
  627.             Integer httpResponseCode = null;
  628.             byte[] risposta = null;
  629.             try {
  630.                 httpResponse = GestoreTokenValidazioneUtilities.http(log, policyGestioneToken, HTTP_TYPE.INTROSPECTION, 
  631.                         dynamicDiscovery, token,
  632.                         pddContext, protocolFactory,
  633.                         datiInvocazione.getState(), portaDelegata, datiInvocazione.getIdModulo(), pa, pd,
  634.                         idDominio, idServizio,
  635.                         busta, datiInvocazione.getRequestInfo());
  636.                 risposta = httpResponse.getContent();
  637.                 httpResponseCode = httpResponse.getResultHTTPOperation();
  638.             }catch(Exception e) {
  639.                 detailsError = PREFIX_ERROR_CONNESSIONE+ e.getMessage();
  640.                 eProcess = e;
  641.             }
  642.             
  643.             if(detailsError==null) {
  644.                 try {
  645.                     informazioniToken = new InformazioniToken(httpResponseCode, SorgenteInformazioniToken.INTROSPECTION, new String(risposta),tokenParser);
  646.                 }catch(Exception e) {
  647.                     detailsError = "Risposta del servizio di Introspection non valida: "+e.getMessage();
  648.                     eProcess = e;
  649.                 }
  650.             }
  651.                     
  652.             if(informazioniToken!=null && informazioniToken.isValid()) {
  653.                 esitoGestioneToken.setTokenValido();
  654.                 esitoGestioneToken.setInformazioniToken(informazioniToken);
  655.                 esitoGestioneToken.setNoCache(false);
  656.             }
  657.             else {
  658.                 esitoGestioneToken.setTokenValidazioneFallita();
  659.                 esitoGestioneToken.setNoCache(!policyGestioneToken.isIntrospectionSaveErrorInCache());
  660.                 esitoGestioneToken.setEccezioneProcessamento(eProcess);
  661.                 if(detailsError!=null) {
  662.                     esitoGestioneToken.setDetails(detailsError);    
  663.                 }
  664.                 else {
  665.                     esitoGestioneToken.setDetails(GestoreToken.TOKEN_NON_VALIDO);   
  666.                 }
  667.                 
  668.                 // comunque lo aggiungo per essere consultabile nei casi di errore se una connessione http è terminata
  669.                 if(OpenSPCoop2Properties.getInstance().isGestioneTokenSaveSourceTokenInfo() && httpResponseCode!=null) {
  670.                     informazioniToken = new InformazioniToken(esitoGestioneToken.getDetails(), httpResponseCode, risposta, SorgenteInformazioniToken.INTROSPECTION, token);
  671.                     esitoGestioneToken.setInformazioniToken(informazioniToken);
  672.                 }
  673.                 
  674.                 if(policyGestioneToken.isMessageErrorGenerateEmptyMessage()) {
  675.                     esitoGestioneToken.setErrorMessage(WWWAuthenticateGenerator.buildErrorMessage(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  676.                             policyGestioneToken.isMessageErrorGenerateGenericMessage(), esitoGestioneToken.getDetails()));              
  677.                 }
  678.                 else {
  679.                     esitoGestioneToken.setWwwAuthenticateErrorHeader(WWWAuthenticateGenerator.buildHeaderValue(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  680.                             policyGestioneToken.isMessageErrorGenerateGenericMessage(), esitoGestioneToken.getDetails()));
  681.                 }   
  682.             }
  683.             
  684.         }catch(Exception e){
  685.             esitoGestioneToken.setTokenInternalError();
  686.             esitoGestioneToken.setDetails(e.getMessage());
  687.             esitoGestioneToken.setEccezioneProcessamento(e);
  688.         }
  689.         
  690.         return esitoGestioneToken;
  691.     }
  692.     
  693.     
  694.     
  695.     
  696.     // ********* [VALIDAZIONE-TOKEN] USER INFO TOKEN ****************** */
  697.     
  698.     static EsitoGestioneToken userInfoTokenEngine(Logger log, AbstractDatiInvocazione datiInvocazione, 
  699.             PdDContext pddContext, IProtocolFactory<?> protocolFactory,
  700.             DynamicDiscovery dynamicDiscovery, 
  701.             String token, boolean portaDelegata,
  702.             Busta busta, IDSoggetto idDominio, IDServizio idServizio) {
  703.         EsitoGestioneToken esitoGestioneToken = null;
  704.         if(portaDelegata) {
  705.             esitoGestioneToken = new EsitoGestioneTokenPortaDelegata();
  706.         }
  707.         else {
  708.             esitoGestioneToken = new EsitoGestioneTokenPortaApplicativa();
  709.         }
  710.         
  711.         esitoGestioneToken.setTokenInternalError();
  712.         esitoGestioneToken.setToken(token);
  713.         
  714.         try{
  715.             PolicyGestioneToken policyGestioneToken = datiInvocazione.getPolicyGestioneToken();
  716.             
  717.             String detailsError = null;
  718.             InformazioniToken informazioniToken = null;
  719.             Exception eProcess = null;
  720.             
  721.             ITokenParser tokenParser = policyGestioneToken.getUserInfoTokenParser();
  722.             
  723.             PortaApplicativa pa = null;
  724.             PortaDelegata pd = null;
  725.             if(datiInvocazione instanceof DatiInvocazionePortaApplicativa) {
  726.                 pa = ((DatiInvocazionePortaApplicativa)datiInvocazione).getPa();
  727.             }
  728.             else if(datiInvocazione instanceof DatiInvocazionePortaDelegata) {
  729.                 pd = ((DatiInvocazionePortaDelegata)datiInvocazione).getPd();
  730.             }
  731.             
  732.             HttpResponse httpResponse = null;
  733.             Integer httpResponseCode = null;
  734.             byte[] risposta = null;
  735.             try {
  736.                 httpResponse = http(log, policyGestioneToken, HTTP_TYPE.USER_INFO, 
  737.                         dynamicDiscovery, token,
  738.                         pddContext, protocolFactory,
  739.                         datiInvocazione.getState(), portaDelegata, datiInvocazione.getIdModulo(), pa, pd,
  740.                         idDominio, idServizio,
  741.                         busta, datiInvocazione.getRequestInfo());
  742.                 risposta = httpResponse.getContent();
  743.                 httpResponseCode = httpResponse.getResultHTTPOperation();
  744.             }catch(Exception e) {
  745.                 detailsError = PREFIX_ERROR_CONNESSIONE+ e.getMessage();
  746.                 eProcess = e;
  747.             }
  748.             
  749.             if(detailsError==null) {
  750.                 try {
  751.                     informazioniToken = new InformazioniToken(httpResponseCode, SorgenteInformazioniToken.USER_INFO, new String(risposta),tokenParser);
  752.                 }catch(Exception e) {
  753.                     detailsError = "Risposta del servizio di UserInfo non valida: "+e.getMessage();
  754.                     eProcess = e;
  755.                 }
  756.             }
  757.                     
  758.             if(informazioniToken!=null && informazioniToken.isValid()) {
  759.                 esitoGestioneToken.setTokenValido();
  760.                 esitoGestioneToken.setInformazioniToken(informazioniToken);
  761.                 esitoGestioneToken.setNoCache(false);
  762.             }
  763.             else {
  764.                 esitoGestioneToken.setTokenValidazioneFallita();
  765.                 esitoGestioneToken.setNoCache(!policyGestioneToken.isUserInfoSaveErrorInCache());
  766.                 esitoGestioneToken.setEccezioneProcessamento(eProcess);
  767.                 if(detailsError!=null) {
  768.                     esitoGestioneToken.setDetails(detailsError);    
  769.                 }
  770.                 else {
  771.                     esitoGestioneToken.setDetails(GestoreToken.TOKEN_NON_VALIDO);   
  772.                 }
  773.                 
  774.                 // comunque lo aggiungo per essere consultabile nei casi di errore se una connessione http è terminata
  775.                 if(OpenSPCoop2Properties.getInstance().isGestioneTokenSaveSourceTokenInfo() && httpResponseCode!=null) {
  776.                     informazioniToken = new InformazioniToken(esitoGestioneToken.getDetails(), httpResponseCode, risposta, SorgenteInformazioniToken.USER_INFO, token);
  777.                     esitoGestioneToken.setInformazioniToken(informazioniToken);
  778.                 }
  779.                 
  780.                 if(policyGestioneToken.isMessageErrorGenerateEmptyMessage()) {
  781.                     esitoGestioneToken.setErrorMessage(WWWAuthenticateGenerator.buildErrorMessage(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  782.                             policyGestioneToken.isMessageErrorGenerateGenericMessage(), esitoGestioneToken.getDetails()));              
  783.                 }
  784.                 else {
  785.                     esitoGestioneToken.setWwwAuthenticateErrorHeader(WWWAuthenticateGenerator.buildHeaderValue(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  786.                             policyGestioneToken.isMessageErrorGenerateGenericMessage(), esitoGestioneToken.getDetails()));
  787.                 }       
  788.             }
  789.             
  790.         }catch(Exception e){
  791.             esitoGestioneToken.setTokenInternalError();
  792.             esitoGestioneToken.setDetails(e.getMessage());
  793.             esitoGestioneToken.setEccezioneProcessamento(e);
  794.         }
  795.         
  796.         return esitoGestioneToken;
  797.     }
  798.     
  799.     
  800.     
  801.     
  802.     
  803.     // ********* [VALIDAZIONE-TOKEN] FORWARD TOKEN ****************** */
  804.     
  805.     static boolean deleteTokenReceived(AbstractDatiInvocazione datiInvocazione, EsitoPresenzaToken esitoPresenzaToken,
  806.             boolean trasparente, String forwardTrasparenteModeHeader, String forwardTrasparenteModeUrl) throws TokenException {
  807.         
  808.         PolicyGestioneToken policyGestioneToken = datiInvocazione.getPolicyGestioneToken();
  809.         
  810.         boolean remove = false;
  811.         if(esitoPresenzaToken.getHeaderHttp()!=null) {
  812.             if( 
  813.                 (!policyGestioneToken.isForwardToken()) 
  814.                 ||
  815.                 (!trasparente) 
  816.                 ||
  817.                 (!esitoPresenzaToken.getHeaderHttp().equalsIgnoreCase(forwardTrasparenteModeHeader))
  818.             ){
  819.                 remove = true;
  820.             }
  821.             if(remove) {
  822.                 datiInvocazione.getMessage().getTransportRequestContext().removeHeader(esitoPresenzaToken.getHeaderHttp());
  823.             }
  824.         }
  825.         else if(esitoPresenzaToken.getPropertyUrl()!=null) {
  826.             if( 
  827.                 (!policyGestioneToken.isForwardToken()) 
  828.                 ||  
  829.                 (!trasparente) 
  830.                 ||
  831.                 (!esitoPresenzaToken.getPropertyUrl().equals(forwardTrasparenteModeUrl)) 
  832.             ){
  833.                 remove = true;
  834.             }
  835.             if(remove) {
  836.                 datiInvocazione.getMessage().getTransportRequestContext().removeParameter(esitoPresenzaToken.getPropertyUrl());
  837.             }
  838.         }
  839.         else if(esitoPresenzaToken.getPropertyFormBased()!=null) {
  840.             if(
  841.                 (!policyGestioneToken.isForwardToken()) 
  842.                 ||
  843.                 (!trasparente) 
  844.             ){
  845.                 remove = true;
  846.             }
  847.             if(remove) {
  848.                 try {
  849.                     byte[] contenuto = datiInvocazione.getMessage().castAsRestBinary().getContent().getContent(); // dovrebbe essere un binary
  850.                     // MyVariableOne=ValueOne&MyVariableTwo=ValueTwo
  851.                     String contenutoAsString = new String(contenuto);
  852.                     String [] split = contenutoAsString.split("&");
  853.                     StringBuilder bf = new StringBuilder();
  854.                     for (int i = 0; i < split.length; i++) {
  855.                         String nameValue = split[i];
  856.                         if(nameValue.contains("=")) {
  857.                             String [] tmp = nameValue.split("=");
  858.                             String name = tmp[0];
  859.                             String value = tmp[1];
  860.                             if(!esitoPresenzaToken.getPropertyFormBased().equals(name)) {
  861.                                 bf.append(name).append("=").append(value);
  862.                             }
  863.                         }
  864.                         else {
  865.                             if(bf.length()>0) {
  866.                                 bf.append("&");
  867.                             }
  868.                             bf.append(nameValue);
  869.                         }
  870.                     }
  871.                     if(bf.length()>0) {
  872.                         byte [] newContenuto = bf.toString().getBytes();
  873.                         ((OpenSPCoop2Message_binary_impl)datiInvocazione.getMessage().castAsRestBinary()).updateContent(newContenuto);
  874.                     }
  875.                     else {
  876.                         datiInvocazione.getMessage().castAsRestBinary().updateContent(null);
  877.                     }
  878.                 }catch(Exception e) {
  879.                     throw new TokenException(e.getMessage(),e);
  880.                 }
  881.             }
  882.         }
  883.         return remove;
  884.     }
  885.     
  886.     static void forwardTokenTrasparenteEngine(String token, EsitoPresenzaToken esitoPresenzaToken, TokenForward tokenForward,
  887.             String forwardTrasparenteMode, String forwardTrasparenteModeHeader, String forwardTrasparenteModeUrl) throws TokenException {
  888.         if(Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_AS_RECEIVED.equals(forwardTrasparenteMode)) {
  889.             if(esitoPresenzaToken.getHeaderHttp()!=null) {
  890.                 if(HttpConstants.AUTHORIZATION.equals(esitoPresenzaToken.getHeaderHttp())) {
  891.                     TransportUtils.setHeader(tokenForward.getTrasporto(),HttpConstants.AUTHORIZATION, HttpConstants.AUTHORIZATION_PREFIX_BEARER+token);
  892.                 }
  893.                 else {
  894.                     TransportUtils.setHeader(tokenForward.getTrasporto(),esitoPresenzaToken.getHeaderHttp(), token);
  895.                 }
  896.             }
  897.             else if(esitoPresenzaToken.getPropertyUrl()!=null) {
  898.                 TransportUtils.setParameter(tokenForward.getUrl(),esitoPresenzaToken.getPropertyUrl(), token);
  899.             }
  900.             else if(esitoPresenzaToken.getPropertyFormBased()!=null) {
  901.                 throw new TokenException("Configurazione non supportata"); // non dovrebbe mai entrare in questo ramo poichè il token non viene eliminato
  902.             }
  903.         }
  904.         else if(Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_RFC6750_HEADER.equals(forwardTrasparenteMode)) {
  905.             TransportUtils.setHeader(tokenForward.getTrasporto(),HttpConstants.AUTHORIZATION, HttpConstants.AUTHORIZATION_PREFIX_BEARER+token);
  906.         }
  907.         else if(Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_RFC6750_URL.equals(forwardTrasparenteMode)) {
  908.             TransportUtils.setParameter(tokenForward.getUrl(),Costanti.RFC6750_URI_QUERY_PARAMETER_ACCESS_TOKEN, token);
  909.         }
  910.         else if(Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_CUSTOM_HEADER.equals(forwardTrasparenteMode)) {
  911.             TransportUtils.setHeader(tokenForward.getTrasporto(),forwardTrasparenteModeHeader, token);
  912.         }
  913.         else if(Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_CUSTOM_URL.equals(forwardTrasparenteMode)) {
  914.             TransportUtils.setParameter(tokenForward.getUrl(),forwardTrasparenteModeUrl, token);
  915.         }
  916.     }
  917.     
  918.     static void forwardInfomazioniRaccolteEngine(boolean portaDelegata, String idTransazione, TokenForward tokenForward,
  919.             EsitoGestioneToken esitoValidazioneJWT, EsitoGestioneToken esitoIntrospection, EsitoGestioneToken esitoUserInfo,
  920.             InformazioniToken informazioniTokenNormalizzate,
  921.             String forwardInforRaccolteMode, Properties jwtSecurity, boolean encodeBase64,
  922.             boolean forwardValidazioneJWT, String forwardValidazioneJWTMode, String forwardValidazioneJWTName,
  923.             boolean forwardIntrospection, String forwardIntrospectionMode, String forwardIntrospectionName,
  924.             boolean forwardUserInfo, String forwardUserInfoMode, String forwardUserInfoName) throws CoreException, UtilsException {
  925.         
  926.         if(informazioniTokenNormalizzate==null) {
  927.             return; // può succedere nei casi warning only, significa che non vi sono token validi
  928.         }
  929.         
  930.         if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_OP2_HEADERS.equals(forwardInforRaccolteMode) ||
  931.                 Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_OP2_JSON.equals(forwardInforRaccolteMode) ||
  932.                 Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_OP2_JWS.equals(forwardInforRaccolteMode)) {
  933.             
  934.             OpenSPCoop2Properties properties = OpenSPCoop2Properties.getInstance();
  935.             Map<String,String> headerNames = null;
  936.             Map<String, Boolean> set = null;
  937.             JSONUtils jsonUtils = null;
  938.             ObjectNode jsonNode = null;
  939.             boolean op2headers = Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_OP2_HEADERS.equals(forwardInforRaccolteMode);
  940.             SimpleDateFormat sdf = null;
  941.             if(op2headers) {
  942.                 headerNames = properties.getKeyValueGestioneTokenHeaderIntegrazioneTrasporto();
  943.                 if(portaDelegata) {
  944.                     set = properties.getKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto();
  945.                 }
  946.                 else {
  947.                     set = properties.getKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto();
  948.                 }
  949.                 String pattern = properties.getGestioneTokenFormatDate();
  950.                 if(pattern!=null && !"".equals(pattern)) {
  951.                     sdf = DateUtils.getDefaultDateTimeFormatter(pattern);
  952.                 }
  953.             }
  954.             else {
  955.                 if(portaDelegata) {
  956.                     set = properties.getKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson();
  957.                 }
  958.                 else {
  959.                     set = properties.getKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson();
  960.                 }
  961.                 jsonUtils = JSONUtils.getInstance();
  962.                 jsonNode = jsonUtils.newObjectNode();
  963.                 jsonNode.put("id", idTransazione);
  964.             }
  965.             
  966.             if(informazioniTokenNormalizzate.getIss()!=null &&
  967.                 set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_ISSUER).booleanValue()) {
  968.                 if(op2headers) {
  969.                     TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_ISSUER), informazioniTokenNormalizzate.getIss());
  970.                 }
  971.                 else {
  972.                     jsonNode.put("issuer", informazioniTokenNormalizzate.getIss());
  973.                 }
  974.             }
  975.             if(informazioniTokenNormalizzate.getSub()!=null &&
  976.                 set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_SUBJECT).booleanValue()) {
  977.                 if(op2headers) {
  978.                     TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_SUBJECT), informazioniTokenNormalizzate.getSub());
  979.                 }
  980.                 else {
  981.                     jsonNode.put("subject", informazioniTokenNormalizzate.getSub());
  982.                 }
  983.             }
  984.             if(informazioniTokenNormalizzate.getUsername()!=null &&
  985.                 set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_USERNAME).booleanValue()) {
  986.                 if(op2headers) {
  987.                     TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_USERNAME), informazioniTokenNormalizzate.getUsername());
  988.                 }
  989.                 else {
  990.                     jsonNode.put("username", informazioniTokenNormalizzate.getUsername());
  991.                 }
  992.             }
  993.             if(informazioniTokenNormalizzate.getAud()!=null &&
  994.                 set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_AUDIENCE).booleanValue()) {
  995.                 ArrayNode array = null;
  996.                 StringBuilder bf = new StringBuilder();
  997.                 if(!op2headers) {
  998.                     array =  jsonUtils.newArrayNode();
  999.                 }
  1000.                 for (String role : informazioniTokenNormalizzate.getAud()) {
  1001.                     if(op2headers) {
  1002.                         if(bf.length()>0) {
  1003.                             bf.append(properties.getGestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator());
  1004.                         }
  1005.                         bf.append(role);
  1006.                     }
  1007.                     else {
  1008.                         array.add(role);
  1009.                     }
  1010.                 }
  1011.                 if(op2headers) {
  1012.                     TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_AUDIENCE), bf.toString());
  1013.                 }
  1014.                 else {
  1015.                     jsonNode.set("audience", array);
  1016.                 }
  1017.             }
  1018.             if(informazioniTokenNormalizzate.getClientId()!=null &&
  1019.                 set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_CLIENT_ID).booleanValue()) {
  1020.                 if(op2headers) {
  1021.                     TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_CLIENT_ID), informazioniTokenNormalizzate.getClientId());
  1022.                 }
  1023.                 else {
  1024.                     jsonNode.put("clientId", informazioniTokenNormalizzate.getClientId());
  1025.                 }
  1026.             }
  1027.             if(informazioniTokenNormalizzate.getIat()!=null &&
  1028.                 set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_ISSUED_AT).booleanValue()) {
  1029.                 if(op2headers) {
  1030.                     String value = null;
  1031.                     if(sdf!=null) {
  1032.                         value = sdf.format(informazioniTokenNormalizzate.getIat());
  1033.                     }
  1034.                     else {
  1035.                         value = (informazioniTokenNormalizzate.getIat().getTime() / 1000) + "";
  1036.                     }
  1037.                     TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_ISSUED_AT), value);
  1038.                 }
  1039.                 else {
  1040.                     jsonNode.put("iat", jsonUtils.getDateFormat().format(informazioniTokenNormalizzate.getIat()));
  1041.                 }
  1042.             }
  1043.             if(informazioniTokenNormalizzate.getExp()!=null &&
  1044.                 set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_EXPIRED).booleanValue()) {
  1045.                 if(op2headers) {
  1046.                     String value = null;
  1047.                     if(sdf!=null) {
  1048.                         value = sdf.format(informazioniTokenNormalizzate.getExp());
  1049.                     }
  1050.                     else {
  1051.                         value = (informazioniTokenNormalizzate.getExp().getTime() / 1000) + "";
  1052.                     }
  1053.                     TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_EXPIRED), value);
  1054.                 }
  1055.                 else {
  1056.                     jsonNode.put("expire", jsonUtils.getDateFormat().format(informazioniTokenNormalizzate.getExp()));
  1057.                 }
  1058.             }
  1059.             if(informazioniTokenNormalizzate.getNbf()!=null &&
  1060.                 set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_NBF).booleanValue()) {
  1061.                 if(op2headers) {
  1062.                     String value = null;
  1063.                     if(sdf!=null) {
  1064.                         value = sdf.format(informazioniTokenNormalizzate.getNbf());
  1065.                     }
  1066.                     else {
  1067.                         value = (informazioniTokenNormalizzate.getNbf().getTime() / 1000) + "";
  1068.                     }
  1069.                     TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_NBF), value);
  1070.                 }
  1071.                 else {
  1072.                     jsonNode.put("nbf", jsonUtils.getDateFormat().format(informazioniTokenNormalizzate.getNbf()));
  1073.                 }
  1074.             }
  1075.             if(informazioniTokenNormalizzate.getRoles()!=null && !informazioniTokenNormalizzate.getRoles().isEmpty() &&
  1076.                 set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_ROLES).booleanValue()) {
  1077.                 ArrayNode array = null;
  1078.                 StringBuilder bf = new StringBuilder();
  1079.                 if(!op2headers) {
  1080.                     array =  jsonUtils.newArrayNode();
  1081.                 }
  1082.                 for (String role : informazioniTokenNormalizzate.getRoles()) {
  1083.                     if(op2headers) {
  1084.                         if(bf.length()>0) {
  1085.                             bf.append(properties.getGestioneTokenHeaderIntegrazioneTrasportoRoleSeparator());
  1086.                         }
  1087.                         bf.append(role);
  1088.                     }
  1089.                     else {
  1090.                         array.add(role);
  1091.                     }
  1092.                 }
  1093.                 if(op2headers) {
  1094.                     TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_ROLES), bf.toString());
  1095.                 }
  1096.                 else {
  1097.                     jsonNode.set("roles", array);
  1098.                 }
  1099.             }
  1100.             if(informazioniTokenNormalizzate.getScopes()!=null && !informazioniTokenNormalizzate.getScopes().isEmpty() &&
  1101.                 set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_SCOPES).booleanValue()) {
  1102.                 ArrayNode array = null;
  1103.                 StringBuilder bf = new StringBuilder();
  1104.                 if(!op2headers) {
  1105.                     array =  jsonUtils.newArrayNode();
  1106.                 }
  1107.                 for (String scope : informazioniTokenNormalizzate.getScopes()) {
  1108.                     if(op2headers) {
  1109.                         if(bf.length()>0) {
  1110.                             bf.append(properties.getGestioneTokenHeaderIntegrazioneTrasportoScopeSeparator());
  1111.                         }
  1112.                         bf.append(scope);
  1113.                     }
  1114.                     else {
  1115.                         array.add(scope);
  1116.                     }
  1117.                 }
  1118.                 if(op2headers) {
  1119.                     TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_SCOPES), bf.toString());
  1120.                 }
  1121.                 else {
  1122.                     jsonNode.set("scopes", array);
  1123.                 }
  1124.             }
  1125.             if(informazioniTokenNormalizzate.getUserInfo()!=null) {
  1126.                 ObjectNode userInfoNode = null;
  1127.                 if(!op2headers) {
  1128.                     userInfoNode = jsonUtils.newObjectNode();
  1129.                 }
  1130.                 
  1131.                 boolean add = false;
  1132.                 
  1133.                 if(informazioniTokenNormalizzate.getUserInfo().getFullName()!=null &&
  1134.                     set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_FULL_NAME).booleanValue()) {
  1135.                     if(op2headers) {
  1136.                         TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_FULL_NAME), informazioniTokenNormalizzate.getUserInfo().getFullName());
  1137.                     }
  1138.                     else {
  1139.                         userInfoNode.put("fullName", informazioniTokenNormalizzate.getUserInfo().getFullName());
  1140.                         add = true;
  1141.                     }
  1142.                 }
  1143.                 if(informazioniTokenNormalizzate.getUserInfo().getFirstName()!=null &&
  1144.                     set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_FIRST_NAME).booleanValue()) {
  1145.                     if(op2headers) {
  1146.                         TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_FIRST_NAME), informazioniTokenNormalizzate.getUserInfo().getFirstName());
  1147.                     }
  1148.                     else {
  1149.                         userInfoNode.put("firstName", informazioniTokenNormalizzate.getUserInfo().getFirstName());
  1150.                         add = true;
  1151.                     }
  1152.                 }
  1153.                 if(informazioniTokenNormalizzate.getUserInfo().getMiddleName()!=null &&
  1154.                     set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_MIDDLE_NAME).booleanValue()) {
  1155.                     if(op2headers) {
  1156.                         TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_MIDDLE_NAME), informazioniTokenNormalizzate.getUserInfo().getMiddleName());
  1157.                     }
  1158.                     else {
  1159.                         userInfoNode.put("middleName", informazioniTokenNormalizzate.getUserInfo().getMiddleName());
  1160.                         add = true;
  1161.                     }
  1162.                 }
  1163.                 if(informazioniTokenNormalizzate.getUserInfo().getFamilyName()!=null &&
  1164.                     set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_FAMILY_NAME).booleanValue()) {
  1165.                     if(op2headers) {
  1166.                         TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_FAMILY_NAME), informazioniTokenNormalizzate.getUserInfo().getFamilyName());
  1167.                     }
  1168.                     else {
  1169.                         userInfoNode.put("familyName", informazioniTokenNormalizzate.getUserInfo().getFamilyName());
  1170.                         add = true;
  1171.                     }
  1172.                 }
  1173.                 if(informazioniTokenNormalizzate.getUserInfo().getEMail()!=null &&
  1174.                     set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_EMAIL).booleanValue()) {
  1175.                     if(op2headers) {
  1176.                         TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_EMAIL), informazioniTokenNormalizzate.getUserInfo().getEMail());
  1177.                     }
  1178.                     else {
  1179.                         userInfoNode.put("eMail", informazioniTokenNormalizzate.getUserInfo().getEMail());
  1180.                         add = true;
  1181.                     }
  1182.                 }
  1183.                 
  1184.                 if(!op2headers && add) {
  1185.                     jsonNode.set("userInfo", userInfoNode);
  1186.                 }
  1187.             }   
  1188.             if(informazioniTokenNormalizzate.getClaims()!=null && !informazioniTokenNormalizzate.getClaims().isEmpty()) {
  1189.                 if(informazioniTokenNormalizzate.getClaims().containsKey(Claims.JSON_WEB_TOKEN_RFC_7519_JWT_ID)) {
  1190.                     Object oPid = informazioniTokenNormalizzate.getClaims().get(Claims.JSON_WEB_TOKEN_RFC_7519_JWT_ID);
  1191.                     if(oPid instanceof String) {
  1192.                         String pId = (String) oPid;
  1193.                         if(set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_JTI).booleanValue()) {
  1194.                             if(op2headers) {
  1195.                                 TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_JTI), pId);
  1196.                             }
  1197.                             else {
  1198.                                 jsonNode.put("jti", pId);
  1199.                             }
  1200.                         }
  1201.                     }
  1202.                 }
  1203.                 if(informazioniTokenNormalizzate.getClaims().containsKey(Costanti.PDND_PURPOSE_ID)) {
  1204.                     Object oPid = informazioniTokenNormalizzate.getClaims().get(Costanti.PDND_PURPOSE_ID);
  1205.                     if(oPid instanceof String) {
  1206.                         String pId = (String) oPid;
  1207.                         if(set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_PURPOSE_ID).booleanValue()) {
  1208.                             if(op2headers) {
  1209.                                 TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_PURPOSE_ID), pId);
  1210.                             }
  1211.                             else {
  1212.                                 jsonNode.put("purposeId", pId);
  1213.                             }
  1214.                         }
  1215.                     }
  1216.                 }
  1217.                 if(informazioniTokenNormalizzate.getPdnd()!=null && !informazioniTokenNormalizzate.getPdnd().isEmpty()) {
  1218.                     
  1219.                     ObjectNode pdndNode = null;
  1220.                     ObjectNode organizationNode = null;
  1221.                     if(!op2headers) {
  1222.                         pdndNode = jsonUtils.newObjectNode();
  1223.                         organizationNode = jsonUtils.newObjectNode();
  1224.                         pdndNode.set("organization", organizationNode);
  1225.                     }
  1226.                     
  1227.                     boolean add = false;
  1228.                     
  1229.                     String organizationName = PDNDTokenInfo.readOrganizationNameFromPDNDMap(informazioniTokenNormalizzate.getPdnd());
  1230.                     if(organizationName!=null && StringUtils.isNotEmpty(organizationName) &&
  1231.                             set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_PDND_ORGANIZATION_NAME).booleanValue()) {
  1232.                         if(op2headers) {
  1233.                             TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_PDND_ORGANIZATION_NAME), organizationName);
  1234.                         }
  1235.                         else {
  1236.                             organizationNode.put("name", organizationName);
  1237.                             add = true;
  1238.                         }
  1239.                     }
  1240.                     
  1241.                     String organizationCategory = PDNDTokenInfo.readOrganizationCategoryFromPDNDMap(informazioniTokenNormalizzate.getPdnd());
  1242.                     if(organizationCategory!=null && StringUtils.isNotEmpty(organizationCategory) &&
  1243.                             set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_PDND_ORGANIZATION_CATEGORY).booleanValue()) {
  1244.                         if(op2headers) {
  1245.                             TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_PDND_ORGANIZATION_CATEGORY), organizationCategory);
  1246.                         }
  1247.                         else {
  1248.                             organizationNode.put("category", organizationCategory);
  1249.                             add = true;
  1250.                         }
  1251.                     }
  1252.                     
  1253.                     String organizationExternalOrigin = PDNDTokenInfo.readOrganizationExternalOriginFromPDNDMap(informazioniTokenNormalizzate.getPdnd());
  1254.                     String organizationExternalId = PDNDTokenInfo.readOrganizationExternalIdFromPDNDMap(informazioniTokenNormalizzate.getPdnd());
  1255.                     StringBuilder sbOrganizationExternal = new StringBuilder();
  1256.                     
  1257.                     if(organizationExternalOrigin!=null && StringUtils.isNotEmpty(organizationExternalOrigin)) {
  1258.                         sbOrganizationExternal.append(organizationExternalOrigin);
  1259.                         if(set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_PDND_ORGANIZATION_EXTERNAL_ORIGIN).booleanValue()) {
  1260.                             if(op2headers) {
  1261.                                 TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_PDND_ORGANIZATION_EXTERNAL_ORIGIN), organizationExternalOrigin);
  1262.                             }
  1263.                             else {
  1264.                                 organizationNode.put("externalOrigin", organizationExternalOrigin);
  1265.                                 add = true;
  1266.                             }
  1267.                         }
  1268.                     }
  1269.                     if(organizationExternalId!=null && StringUtils.isNotEmpty(organizationExternalId)) {
  1270.                         if(sbOrganizationExternal.length()>0) {
  1271.                             sbOrganizationExternal.append(" ");
  1272.                         }
  1273.                         sbOrganizationExternal.append(organizationExternalId);
  1274.                         if(set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_PDND_ORGANIZATION_EXTERNAL_ID).booleanValue()) {
  1275.                             if(op2headers) {
  1276.                                 TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_PDND_ORGANIZATION_EXTERNAL_ID), organizationExternalId);
  1277.                             }
  1278.                             else {
  1279.                                 organizationNode.put("externalId", organizationExternalId);
  1280.                                 add = true;
  1281.                             }
  1282.                         }
  1283.                     }
  1284.                     
  1285.                     String organizationExternal = sbOrganizationExternal.toString();
  1286.                     if(organizationExternal!=null && StringUtils.isNotEmpty(organizationExternal) &&
  1287.                             set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_PDND_ORGANIZATION_EXTERNAL).booleanValue()) {
  1288.                         if(op2headers) {
  1289.                             TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_PDND_ORGANIZATION_EXTERNAL), organizationExternal);
  1290.                         }
  1291.                         else {
  1292.                             organizationNode.put("external", organizationExternal);
  1293.                             add = true;
  1294.                         }
  1295.                     }
  1296.                     
  1297.                     if(!op2headers && add) {
  1298.                         jsonNode.set("pdnd", pdndNode);
  1299.                     }
  1300.                 }
  1301.             }
  1302.             List<String> listCustomClaims = properties.getCustomClaimsKeysGestioneTokenForward();
  1303.             if(listCustomClaims!=null && !listCustomClaims.isEmpty()) {
  1304.                 
  1305.                 ArrayNode customClaimsNode = null;
  1306.                 if(!op2headers) {
  1307.                     customClaimsNode = jsonUtils.newArrayNode();
  1308.                 }
  1309.                 
  1310.                 boolean add = false;
  1311.                 
  1312.                 for (String claimKey : listCustomClaims) {
  1313.                 
  1314.                     String claimName = properties.getCustomClaimsNameGestioneTokenHeaderIntegrazione(claimKey);
  1315.                     
  1316.                     if(informazioniTokenNormalizzate.getClaims()!=null && informazioniTokenNormalizzate.getClaims().containsKey(claimName)) {
  1317.                         
  1318.                         Object claimValueObject = informazioniTokenNormalizzate.getClaims().get(claimName);
  1319.                         List<String> claimValues = null;
  1320.                         if(claimValueObject!=null) {
  1321.                             claimValues = TokenUtilities.getClaimValues(claimValueObject);
  1322.                         }
  1323.                         String headerName = null;
  1324.                         if(claimValues!=null && !claimValues.isEmpty()) {
  1325.                             boolean setCustomClaims = false;
  1326.                             if(op2headers) {
  1327.                                 headerName = properties.getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto(claimKey);
  1328.                                 if(portaDelegata) {
  1329.                                     setCustomClaims = properties.getCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto(claimKey);
  1330.                                 }
  1331.                                 else {
  1332.                                     setCustomClaims = properties.getCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto(claimKey);
  1333.                                 }
  1334.                             }
  1335.                             else {
  1336.                                 headerName = properties.getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson(claimKey);
  1337.                                 if(portaDelegata) {
  1338.                                     setCustomClaims = properties.getCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson(claimKey);
  1339.                                 }
  1340.                                 else {
  1341.                                     setCustomClaims = properties.getCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson(claimKey);
  1342.                                 }
  1343.                             }
  1344.                             
  1345.                             if(setCustomClaims) {
  1346.                                 String claimValue = TokenUtilities.getClaimValuesAsString(claimValues);
  1347.                                 if(op2headers) {
  1348.                                     TransportUtils.setHeader(tokenForward.getTrasporto(),headerName, claimValue);
  1349.                                 }
  1350.                                 else {
  1351.                                     ObjectNode propertyNode = jsonUtils.newObjectNode();
  1352.                                     propertyNode.put("name", headerName);
  1353.                                     propertyNode.put("value", claimValue);
  1354.                                     customClaimsNode.add(propertyNode);
  1355.                                     add = true;
  1356.                                 }
  1357.                             }
  1358.                         }
  1359.                     }
  1360.                     
  1361.                 }
  1362.                 
  1363.                 if(!op2headers && add) {
  1364.                     jsonNode.set("claims", customClaimsNode);
  1365.                 }
  1366.             }

  1368.             Date processTime = DateManager.getDate();
  1369.             if(set.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_PROCESS_TIME).booleanValue()) {
  1370.                 if(op2headers) {
  1371.                     String value = null;
  1372.                     if(sdf!=null) {
  1373.                         value = sdf.format(processTime);
  1374.                     }
  1375.                     else {
  1376.                         value = (processTime.getTime() / 1000) + "";
  1377.                     }
  1378.                     TransportUtils.setHeader(tokenForward.getTrasporto(),headerNames.get(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_PROCESS_TIME), value);
  1379.                 }
  1380.                 else {
  1381.                     jsonNode.put("processTime", jsonUtils.getDateFormat().format(processTime));
  1382.                 }
  1383.             }
  1384.             
  1385.             if(!op2headers) {
  1386.                 String json = jsonUtils.toString(jsonNode);
  1387.                 if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_OP2_JSON.equals(forwardInforRaccolteMode)) {
  1388.                     String headerName = properties.getGestioneTokenHeaderTrasportoJSON();
  1389.                     if(encodeBase64) {
  1390.                         TransportUtils.setHeader(tokenForward.getTrasporto(),headerName, Base64Utilities.encodeAsString(json.getBytes()));
  1391.                     }
  1392.                     else {
  1393.                         TransportUtils.setHeader(tokenForward.getTrasporto(),headerName, json);
  1394.                     }
  1395.                 }
  1396.                 else {
  1397.                     // JWS Compact
  1398.                     JWSOptions jwsOptions = new JWSOptions(JOSESerialization.COMPACT);
  1399.                     JsonSignature jsonCompactSignature = new JsonSignature(jwtSecurity,jwsOptions);
  1400.                     String compact = jsonCompactSignature.sign(json);
  1401.                     String headerName = properties.getGestioneTokenHeaderTrasportoJWT();
  1402.                     TransportUtils.setHeader(tokenForward.getTrasporto(),headerName, compact);
  1403.                 }
  1404.             }
  1405.         } 
  1406.         else {
  1407.             
  1408.             if(forwardValidazioneJWT && esitoValidazioneJWT!=null && esitoValidazioneJWT.isValido() && 
  1409.                     esitoValidazioneJWT.getInformazioniToken()!=null &&
  1410.                     esitoValidazioneJWT.getInformazioniToken().getRawResponse()!=null) {
  1411.                 
  1412.                 String value = esitoValidazioneJWT.getInformazioniToken().getRawResponse();
  1413.                 if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JWS.equals(forwardInforRaccolteMode)) {
  1414.                     // JWS Compact              
  1415.                     JWSOptions jwsOptions = new JWSOptions(JOSESerialization.COMPACT);
  1416.                     JsonSignature jsonCompactSignature = new JsonSignature(jwtSecurity,jwsOptions);
  1417.                     value = jsonCompactSignature.sign(value);
  1418.                 }
  1419.                 else if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JWE.equals(forwardInforRaccolteMode)) {
  1420.                     // JWE Compact
  1421.                     JWEOptions jweOptions = new JWEOptions(JOSESerialization.COMPACT);
  1422.                     JsonEncrypt jsonCompactEncrypt = new JsonEncrypt(jwtSecurity,jweOptions);
  1423.                     value = jsonCompactEncrypt.encrypt(value);
  1424.                 }
  1425.                 else {
  1426.                     //Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JSON
  1427.                     if(encodeBase64) {
  1428.                         value = Base64Utilities.encodeAsString(value.getBytes());
  1429.                     }
  1430.                 }
  1431.                 if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_NO_OPENSPCOOP_CUSTOM_HEADER.equals(forwardValidazioneJWTMode)) {
  1432.                     TransportUtils.setHeader(tokenForward.getTrasporto(),forwardValidazioneJWTName, value);
  1433.                 }
  1434.                 else {
  1435.                     TransportUtils.setParameter(tokenForward.getUrl(),forwardValidazioneJWTName, value);
  1436.                 }
  1437.                 
  1438.             }
  1439.             
  1440.             if(forwardIntrospection && esitoIntrospection!=null && esitoIntrospection.isValido() && 
  1441.                     esitoIntrospection.getInformazioniToken()!=null &&
  1442.                     esitoIntrospection.getInformazioniToken().getRawResponse()!=null) {
  1443.                 
  1444.                 String value = esitoIntrospection.getInformazioniToken().getRawResponse();
  1445.                 if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JWS.equals(forwardInforRaccolteMode)) {
  1446.                     // JWS Compact              
  1447.                     JWSOptions jwsOptions = new JWSOptions(JOSESerialization.COMPACT);
  1448.                     JsonSignature jsonCompactSignature = new JsonSignature(jwtSecurity,jwsOptions);
  1449.                     value = jsonCompactSignature.sign(value);
  1450.                 }
  1451.                 else if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JWE.equals(forwardInforRaccolteMode)) {
  1452.                     // JWE Compact
  1453.                     JWEOptions jweOptions = new JWEOptions(JOSESerialization.COMPACT);
  1454.                     JsonEncrypt jsonCompactEncrypt = new JsonEncrypt(jwtSecurity,jweOptions);
  1455.                     value = jsonCompactEncrypt.encrypt(value);
  1456.                 }
  1457.                 else {
  1458.                     //Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JSON
  1459.                     if(encodeBase64) {
  1460.                         value = Base64Utilities.encodeAsString(value.getBytes());
  1461.                     }
  1462.                 }
  1463.                 if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_NO_OPENSPCOOP_CUSTOM_HEADER.equals(forwardIntrospectionMode)) {
  1464.                     TransportUtils.setHeader(tokenForward.getTrasporto(),forwardIntrospectionName, value);
  1465.                 }
  1466.                 else {
  1467.                     TransportUtils.setParameter(tokenForward.getUrl(),forwardIntrospectionName, value);
  1468.                 }
  1469.                 
  1470.             }
  1471.             
  1472.             if(forwardUserInfo && esitoUserInfo!=null && esitoUserInfo.isValido() && 
  1473.                     esitoUserInfo.getInformazioniToken()!=null &&
  1474.                     esitoUserInfo.getInformazioniToken().getRawResponse()!=null) {
  1475.                 
  1476.                 String value = esitoUserInfo.getInformazioniToken().getRawResponse();
  1477.                 if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JWS.equals(forwardInforRaccolteMode)) {
  1478.                     // JWS Compact              
  1479.                     JWSOptions jwsOptions = new JWSOptions(JOSESerialization.COMPACT);
  1480.                     JsonSignature jsonCompactSignature = new JsonSignature(jwtSecurity,jwsOptions);
  1481.                     value = jsonCompactSignature.sign(value);
  1482.                 }
  1483.                 else if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JWE.equals(forwardInforRaccolteMode)) {
  1484.                     // JWE Compact
  1485.                     JWEOptions jweOptions = new JWEOptions(JOSESerialization.COMPACT);
  1486.                     JsonEncrypt jsonCompactEncrypt = new JsonEncrypt(jwtSecurity,jweOptions);
  1487.                     value = jsonCompactEncrypt.encrypt(value);
  1488.                 }
  1489.                 else {
  1490.                     //Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JSON
  1491.                     if(encodeBase64) {
  1492.                         value = Base64Utilities.encodeAsString(value.getBytes());
  1493.                     }
  1494.                 }
  1495.                 if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_NO_OPENSPCOOP_CUSTOM_HEADER.equals(forwardUserInfoMode)) {
  1496.                     TransportUtils.setHeader(tokenForward.getTrasporto(),forwardUserInfoName, value);
  1497.                 }
  1498.                 else {
  1499.                     TransportUtils.setParameter(tokenForward.getUrl(),forwardUserInfoName, value);
  1500.                 }
  1501.                 
  1502.             }
  1503.             
  1504.         }
  1505.         
  1506.     }
  1507.     
  1508.     
  1509.     
  1510.     
  1511.     
  1512.     
  1513.     // ********* [VALIDAZIONE-TOKEN] UTILITIES INTERNE ****************** */
  1514.     
  1515.     public static boolean isExpired(Date now, Date exp) throws TokenException {
  1516.         
  1517.         Date checkNow = now;
  1518.         Long tolerance = null;
  1519.         try {
  1520.             tolerance = OpenSPCoop2Properties.getInstance().getGestioneTokenExpTimeCheckToleranceMilliseconds();
  1521.         }catch(Exception e) {
  1522.             throw new TokenException(e.getMessage(),e);
  1523.         }
  1524.         if(tolerance!=null && tolerance.longValue()>0) {
  1525.             checkNow = new Date(now.getTime() - tolerance.longValue());
  1526.         }
  1527.         
  1528.         return !checkNow.before(exp);
  1529.     }
  1530.     public static boolean isFuture(Date now, Date nbf) throws TokenException {
  1531.         
  1532.         Date checkNow = now;
  1533.         Long tolerance = null;
  1534.         try {
  1535.             tolerance = OpenSPCoop2Properties.getInstance().getGestioneTokenNbfTimeCheckToleranceMilliseconds();
  1536.         }catch(Exception e) {
  1537.             throw new TokenException(e.getMessage(),e);
  1538.         }
  1539.         if(tolerance!=null && tolerance.longValue()>0) {
  1540.             checkNow = new Date(now.getTime() + tolerance.longValue());
  1541.         }
  1542.         
  1543.         return !nbf.before(checkNow);
  1544.     }
  1545.     
  1546.     public static boolean isProfiloModIPAEnabled() {
  1547.         try {
  1548.             Enumeration<String> en = ProtocolFactoryManager.getInstance().getProtocolNames();
  1549.             while (en.hasMoreElements()) {
  1550.                 String protocollo = en.nextElement();
  1551.                 if(protocollo.equals(CostantiLabel.MODIPA_PROTOCOL_NAME)) {
  1552.                     return true;
  1553.                 }
  1554.             }
  1555.             return false;
  1556.         }catch(Throwable t) {
  1557.             return false;
  1558.         }
  1559.     }
  1560.     
  1561.     private static List<String> policyGestioneTokenPDND = null;
  1562.     private static synchronized void initPolicyGestioneTokenPDND(Logger log) {
  1563.         if(policyGestioneTokenPDND==null) {
  1564.             try {
  1565.                 policyGestioneTokenPDND = new ArrayList<>();
  1566.                 if(isProfiloModIPAEnabled()) {
  1567.                     initPolicyGestioneTokenPDND();
  1568.                 }
  1569.             }catch(Exception e) {
  1570.                 log.error("Errore di inizializzazione policy 'PDND': "+e.getMessage(), e);
  1571.             }
  1572.         }
  1573.     }
  1574.     private static synchronized void initPolicyGestioneTokenPDND() throws ProtocolException {
  1575.         List<RemoteStoreConfig> listRSC = ModIUtils.getRemoteStoreConfig();
  1576.         if(listRSC!=null && !listRSC.isEmpty()) {
  1577.             for (RemoteStoreConfig r : listRSC) {
  1578.                 if(!policyGestioneTokenPDND.contains(r.getTokenPolicy())) {
  1579.                     policyGestioneTokenPDND.add(r.getTokenPolicy());
  1580.                 }
  1581.             }
  1582.         }
  1583.     }
  1584.     private static boolean isPdndTokenPolicy(Logger log, String tokenPolicy) {
  1585.         if(policyGestioneTokenPDND==null) {
  1586.             initPolicyGestioneTokenPDND(log) ;
  1587.         }
  1588.         return policyGestioneTokenPDND.contains(tokenPolicy);
  1589.     }
  1590.     
  1591.     private static List<Proprieta> readProprieta(AbstractDatiInvocazione datiInvocazione) throws DriverConfigurazioneException {
  1592.         List<Proprieta> l = null;
  1593.         if(datiInvocazione instanceof DatiInvocazionePortaDelegata) {
  1594.             DatiInvocazionePortaDelegata d = (DatiInvocazionePortaDelegata) datiInvocazione;
  1595.             PortaDelegata pd = d.getPd();
  1596.             if(pd==null && d.getIdPD()!=null) {
  1597.                 ConfigurazionePdDManager configManager = ConfigurazionePdDManager.getInstance(datiInvocazione.getState());
  1598.                 pd = configManager.getPortaDelegataSafeMethod(d.getIdPD(), datiInvocazione.getRequestInfo());
  1599.             }
  1600.             if(pd!=null) {
  1601.                 return pd.getProprieta();
  1602.             }
  1603.         }
  1604.         else {
  1605.             DatiInvocazionePortaApplicativa d = (DatiInvocazionePortaApplicativa) datiInvocazione;
  1606.             PortaApplicativa pa = d.getPa();
  1607.             if(pa==null && d.getIdPA()!=null) {
  1608.                 ConfigurazionePdDManager configManager = ConfigurazionePdDManager.getInstance(datiInvocazione.getState());
  1609.                 pa = configManager.getPortaApplicativaSafeMethod(d.getIdPA(), datiInvocazione.getRequestInfo());
  1610.             }
  1611.             if(pa!=null) {
  1612.                 return pa.getProprieta();
  1613.             }
  1614.         }
  1615.         return l;
  1616.     }
  1617.     
  1618.     static boolean isIatRequired(Logger log, PolicyGestioneToken policyGestioneToken, AbstractDatiInvocazione datiInvocazione, IProtocolFactory<?> protocollo, OpenSPCoop2Properties op2Properties) throws CoreException {
  1619.         
  1620.         String p = protocollo!=null ? protocollo.getProtocol() : "";
  1621.         
  1622.         boolean delegata = datiInvocazione instanceof DatiInvocazionePortaDelegata;
  1623.         
  1624.         boolean required = op2Properties.isGestioneTokenIatRequired();
  1625.         BooleanNullable bn = op2Properties.isGestioneTokenIatRequired(delegata, p);
  1626.         if(bn!=null && bn.getValue()!=null) {
  1627.             required = bn.getValue().booleanValue();
  1628.         }
  1629.         
  1630.         if(!delegata && isPdndTokenPolicy(log, policyGestioneToken.getName())) {
  1631.             bn = op2Properties.isGestioneTokenIatPdndRequired();
  1632.             if(bn!=null && bn.getValue()!=null) {
  1633.                 required = bn.getValue().booleanValue();
  1634.             }
  1635.         }
  1636.         
  1637.         try {
  1638.             List<Proprieta> props = readProprieta(datiInvocazione);
  1639.             return CostantiProprieta.isTokenValidationClaimsIatRequired(props, required);
  1640.         }catch(Exception e) {
  1641.             throw new CoreException(e.getMessage(),e);
  1642.         }
  1643.     }
  1644.     
  1645.     static boolean isExpRequired(Logger log, PolicyGestioneToken policyGestioneToken, AbstractDatiInvocazione datiInvocazione, IProtocolFactory<?> protocollo, OpenSPCoop2Properties op2Properties) throws CoreException {
  1646.         
  1647.         String p = protocollo!=null ? protocollo.getProtocol() : "";
  1648.         
  1649.         boolean delegata = datiInvocazione instanceof DatiInvocazionePortaDelegata;
  1650.         
  1651.         boolean required = op2Properties.isGestioneTokenExpRequired();
  1652.         BooleanNullable bn = op2Properties.isGestioneTokenExpRequired(delegata, p);
  1653.         if(bn!=null && bn.getValue()!=null) {
  1654.             required = bn.getValue().booleanValue();
  1655.         }
  1656.         
  1657.         if(!delegata && isPdndTokenPolicy(log, policyGestioneToken.getName())) {
  1658.             bn = op2Properties.isGestioneTokenExpPdndRequired();
  1659.             if(bn!=null && bn.getValue()!=null) {
  1660.                 required = bn.getValue().booleanValue();
  1661.             }
  1662.         }
  1663.         
  1664.         try {
  1665.             List<Proprieta> props = readProprieta(datiInvocazione);
  1666.             return CostantiProprieta.isTokenValidationClaimsExpRequired(props, required);
  1667.         }catch(Exception e) {
  1668.             throw new CoreException(e.getMessage(),e);
  1669.         }
  1670.     }
  1671.     
  1672.     static boolean isNbfRequired(Logger log, PolicyGestioneToken policyGestioneToken, AbstractDatiInvocazione datiInvocazione, IProtocolFactory<?> protocollo, OpenSPCoop2Properties op2Properties) throws CoreException {
  1673.         
  1674.         String p = protocollo!=null ? protocollo.getProtocol() : "";
  1675.         
  1676.         boolean delegata = datiInvocazione instanceof DatiInvocazionePortaDelegata;
  1677.         
  1678.         boolean required = op2Properties.isGestioneTokenNbfRequired();
  1679.         BooleanNullable bn = op2Properties.isGestioneTokenNbfRequired(delegata, p);
  1680.         if(bn!=null && bn.getValue()!=null) {
  1681.             required = bn.getValue().booleanValue();
  1682.         }
  1683.         
  1684.         if(!delegata && isPdndTokenPolicy(log, policyGestioneToken.getName())) {
  1685.             bn = op2Properties.isGestioneTokenNbfPdndRequired();
  1686.             if(bn!=null && bn.getValue()!=null) {
  1687.                 required = bn.getValue().booleanValue();
  1688.             }
  1689.         }
  1690.         
  1691.         try {
  1692.             List<Proprieta> props = readProprieta(datiInvocazione);
  1693.             return CostantiProprieta.isTokenValidationClaimsNbfRequired(props, required);
  1694.         }catch(Exception e) {
  1695.             throw new CoreException(e.getMessage(),e);
  1696.         }
  1697.     }
  1698.     
  1699.     static void validazioneInformazioniToken(boolean checkRequired, // verranno controllati solo nella validazione jwt
  1700.             Logger log, AbstractDatiInvocazione datiInvocazione, IProtocolFactory<?> protocolFactory, 
  1701.             EsitoGestioneToken esitoGestioneToken, PolicyGestioneToken policyGestioneToken, boolean saveErrorInCache) throws TokenException, CoreException {
  1702.         
  1703.         Date now = DateManager.getDate();
  1704.         
  1705.         if(esitoGestioneToken.isValido()) {
  1706.             esitoGestioneToken.setDateValide(true); // tanto le ricontrollo adesso
  1707.         }
  1708.             
  1709.         OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  1710.         
  1711.         /** === EXP === ***/
  1712.         
  1713.         if(esitoGestioneToken.isValido() && checkRequired) {
  1714.             
  1715.             boolean check = isExpRequired(log, policyGestioneToken, datiInvocazione, protocolFactory, op2Properties);
  1716.             if(check && esitoGestioneToken.getInformazioniToken().getExp()==null) {
  1717.                 esitoGestioneToken.setTokenValidazioneFallita();
  1718.                 esitoGestioneToken.setDateValide(false);
  1719.                 esitoGestioneToken.setDetails("Token rejected; the 'exp' (expiration time) claim is required but missing.");
  1720.                 if(policyGestioneToken.isMessageErrorGenerateEmptyMessage()) {
  1721.                     esitoGestioneToken.setErrorMessage(WWWAuthenticateGenerator.buildErrorMessage(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  1722.                             false, // ritorno l'errore preciso in questo caso // policyGestioneToken.isGenericError(), 
  1723.                             esitoGestioneToken.getDetails()));          
  1724.                 }
  1725.                 else {
  1726.                     esitoGestioneToken.setWwwAuthenticateErrorHeader(WWWAuthenticateGenerator.buildHeaderValue(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  1727.                             false, // ritorno l'errore preciso in questo caso // policyGestioneToken.isGenericError(), 
  1728.                             esitoGestioneToken.getDetails()));
  1729.                 }   
  1730.             }
  1731.             
  1732.         }
  1733.         
  1734.         if(esitoGestioneToken.isValido()) {
  1735.             
  1736.             boolean enabled = op2Properties.isGestioneTokenExpTimeCheck();
  1737.             
  1738.             if(enabled && esitoGestioneToken.getInformazioniToken().getExp()!=null) {   
  1739.                 
  1740.                 boolean expired = isExpired(now, esitoGestioneToken.getInformazioniToken().getExp());

  1742.                 /*
  1743.                  *   The "exp" (expiration time) claim identifies the expiration time on
  1744.                  *   or after which the JWT MUST NOT be accepted for processing.  The
  1745.                  *   processing of the "exp" claim requires that the current date/time
  1746.                  *   MUST be before the expiration date/time listed in the "exp" claim.
  1747.                  **/
  1748.                 if(expired){
  1749.                     esitoGestioneToken.setTokenScaduto();
  1750.                     esitoGestioneToken.setDateValide(false);
  1751.                     esitoGestioneToken.setDetails("Token expired");
  1752.                     if(policyGestioneToken.isMessageErrorGenerateEmptyMessage()) {
  1753.                         esitoGestioneToken.setErrorMessage(WWWAuthenticateGenerator.buildErrorMessage(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  1754.                                 false, // ritorno l'errore preciso in questo caso // policyGestioneToken.isGenericError(), 
  1755.                                 esitoGestioneToken.getDetails()));          
  1756.                     }
  1757.                     else {
  1758.                         esitoGestioneToken.setWwwAuthenticateErrorHeader(WWWAuthenticateGenerator.buildHeaderValue(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  1759.                                 false, // ritorno l'errore preciso in questo caso // policyGestioneToken.isGenericError(), 
  1760.                                 esitoGestioneToken.getDetails()));
  1761.                     }   
  1762.                 }
  1763.             }
  1764.             
  1765.         }
  1766.             
  1767.         
  1768.         
  1769.         /** === NBF === ***/
  1770.         
  1771.         if(esitoGestioneToken.isValido() && checkRequired) {
  1772.             
  1773.             boolean check = isNbfRequired(log, policyGestioneToken, datiInvocazione, protocolFactory, op2Properties);
  1774.             if(check && esitoGestioneToken.getInformazioniToken().getNbf()==null) {
  1775.                 esitoGestioneToken.setTokenValidazioneFallita();
  1776.                 esitoGestioneToken.setDateValide(false);
  1777.                 esitoGestioneToken.setDetails("Token rejected; the 'nbf' (not before) claim is required but missing.");
  1778.                 if(policyGestioneToken.isMessageErrorGenerateEmptyMessage()) {
  1779.                     esitoGestioneToken.setErrorMessage(WWWAuthenticateGenerator.buildErrorMessage(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  1780.                             false, // ritorno l'errore preciso in questo caso // policyGestioneToken.isGenericError(), 
  1781.                             esitoGestioneToken.getDetails()));          
  1782.                 }
  1783.                 else {
  1784.                     esitoGestioneToken.setWwwAuthenticateErrorHeader(WWWAuthenticateGenerator.buildHeaderValue(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  1785.                             false, // ritorno l'errore preciso in questo caso // policyGestioneToken.isGenericError(), 
  1786.                             esitoGestioneToken.getDetails()));
  1787.                 }   
  1788.             }
  1789.             
  1790.         }
  1791.         
  1792.         if(esitoGestioneToken.isValido() &&
  1793.             esitoGestioneToken.getInformazioniToken().getNbf()!=null) {
  1794.             
  1795.             boolean future = isFuture(now, esitoGestioneToken.getInformazioniToken().getNbf());
  1796.             
  1797.             /*
  1798.              *   The "nbf" (not before) claim identifies the time before which the JWT
  1799.              *   MUST NOT be accepted for processing.  The processing of the "nbf"
  1800.              *   claim requires that the current date/time MUST be after or equal to
  1801.              *   the not-before date/time listed in the "nbf" claim. 
  1802.              **/
  1803.             
  1804.             if(future){
  1805.                 esitoGestioneToken.setTokenNotUsableBefore();
  1806.                 esitoGestioneToken.setDateValide(false);
  1807.                 SimpleDateFormat sdf = DateUtils.getDefaultDateTimeFormatter(GestoreToken.DATE_FORMAT);
  1808.                 esitoGestioneToken.setDetails("Token not usable before "+sdf.format(esitoGestioneToken.getInformazioniToken().getNbf()));
  1809.                 if(policyGestioneToken.isMessageErrorGenerateEmptyMessage()) {
  1810.                     esitoGestioneToken.setErrorMessage(WWWAuthenticateGenerator.buildErrorMessage(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  1811.                             false, // ritorno l'errore preciso in questo caso // policyGestioneToken.isGenericError(), 
  1812.                             esitoGestioneToken.getDetails()));  
  1813.                 }
  1814.                 else {
  1815.                     esitoGestioneToken.setWwwAuthenticateErrorHeader(WWWAuthenticateGenerator.buildHeaderValue(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  1816.                             false, // ritorno l'errore preciso in questo caso // policyGestioneToken.isGenericError(), 
  1817.                             esitoGestioneToken.getDetails()));
  1818.                 } 
  1819.             }
  1820.         }
  1821.         
  1822.         
  1823.         
  1824.         
  1825.         /** === IAT === ***/
  1826.         
  1827.         if(esitoGestioneToken.isValido() && checkRequired) {
  1828.             
  1829.             boolean check = isIatRequired(log, policyGestioneToken, datiInvocazione, protocolFactory, op2Properties);
  1830.             if(check && esitoGestioneToken.getInformazioniToken().getIat()==null) {
  1831.                 esitoGestioneToken.setTokenValidazioneFallita();
  1832.                 esitoGestioneToken.setDateValide(false);
  1833.                 esitoGestioneToken.setDetails("Token rejected; the 'iat' (issued at) claim is required but missing.");
  1834.                 if(policyGestioneToken.isMessageErrorGenerateEmptyMessage()) {
  1835.                     esitoGestioneToken.setErrorMessage(WWWAuthenticateGenerator.buildErrorMessage(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  1836.                             false, // ritorno l'errore preciso in questo caso // policyGestioneToken.isGenericError(), 
  1837.                             esitoGestioneToken.getDetails()));          
  1838.                 }
  1839.                 else {
  1840.                     esitoGestioneToken.setWwwAuthenticateErrorHeader(WWWAuthenticateGenerator.buildHeaderValue(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  1841.                             false, // ritorno l'errore preciso in questo caso // policyGestioneToken.isGenericError(), 
  1842.                             esitoGestioneToken.getDetails()));
  1843.                 }   
  1844.             }
  1845.             
  1846.         }
  1847.         
  1848.         if(esitoGestioneToken.isValido() &&
  1849.             esitoGestioneToken.getInformazioniToken().getIat()!=null) {             
  1850.             /*
  1851.              *   The "iat" (issued at) claim identifies the time at which the JWT was
  1852.              *   issued.  This claim can be used to determine the age of the JWT.
  1853.              *   The iat Claim can be used to reject tokens that were issued too far away from the current time, 
  1854.              *   limiting the amount of time that nonces need to be stored to prevent attacks. The acceptable range is Client specific. 
  1855.              **/
  1856.             Long old = op2Properties.getGestioneTokenIatTimeCheckMilliseconds();
  1857.             if(old!=null) {
  1858.                 Date oldMax = new Date((DateManager.getTimeMillis() - old.longValue()));
  1859.                 if(esitoGestioneToken.getInformazioniToken().getIat().before(oldMax)) {
  1860.                     esitoGestioneToken.setTokenScaduto();
  1861.                     esitoGestioneToken.setDateValide(false);
  1862.                     SimpleDateFormat sdf = DateUtils.getDefaultDateTimeFormatter(GestoreToken.DATE_FORMAT);
  1863.                     esitoGestioneToken.setDetails("Token expired; iat time '"+sdf.format(esitoGestioneToken.getInformazioniToken().getIat())+"' too old");
  1864.                     if(policyGestioneToken.isMessageErrorGenerateEmptyMessage()) {
  1865.                         esitoGestioneToken.setErrorMessage(WWWAuthenticateGenerator.buildErrorMessage(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  1866.                                 false, // ritorno l'errore preciso in questo caso // policyGestioneToken.isGenericError(), 
  1867.                                 esitoGestioneToken.getDetails()));  
  1868.                     }
  1869.                     else {
  1870.                         esitoGestioneToken.setWwwAuthenticateErrorHeader(WWWAuthenticateGenerator.buildHeaderValue(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  1871.                                 false, // ritorno l'errore preciso in questo caso // policyGestioneToken.isGenericError(), 
  1872.                                 esitoGestioneToken.getDetails()));
  1873.                     } 
  1874.                 }
  1875.             }
  1876.             
  1877.             Long future = op2Properties.getGestioneTokenIatTimeCheckFutureToleranceMilliseconds();
  1878.             if(future!=null && future.longValue()>0) {
  1879.                 Date futureMax = new Date((DateManager.getTimeMillis() + future.longValue()));
  1880.                 if(esitoGestioneToken.getInformazioniToken().getIat().after(futureMax)) {
  1881.                     esitoGestioneToken.setTokenInTheFuture();
  1882.                     esitoGestioneToken.setDateValide(false);
  1883.                     SimpleDateFormat sdf = DateUtils.getDefaultDateTimeFormatter(GestoreToken.DATE_FORMAT);
  1884.                     esitoGestioneToken.setDetails("Token valid in the future; iat time '"+sdf.format(esitoGestioneToken.getInformazioniToken().getIat())+"' is in the future");
  1885.                     if(policyGestioneToken.isMessageErrorGenerateEmptyMessage()) {
  1886.                         esitoGestioneToken.setErrorMessage(WWWAuthenticateGenerator.buildErrorMessage(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  1887.                                 false, // ritorno l'errore preciso in questo caso // policyGestioneToken.isGenericError(), 
  1888.                                 esitoGestioneToken.getDetails()));  
  1889.                     }
  1890.                     else {
  1891.                         esitoGestioneToken.setWwwAuthenticateErrorHeader(WWWAuthenticateGenerator.buildHeaderValue(WWWAuthenticateErrorCode.invalid_token, policyGestioneToken.getRealm(), 
  1892.                                 false, // ritorno l'errore preciso in questo caso // policyGestioneToken.isGenericError(), 
  1893.                                 esitoGestioneToken.getDetails()));
  1894.                     } 
  1895.                 }
  1896.             }
  1897.             
  1898.         }
  1899.         
  1900.         if(!esitoGestioneToken.isValido()) {
  1901.             esitoGestioneToken.setNoCache(!saveErrorInCache);
  1902.         }
  1903.     }
  1904.     
  1905.     static void validazioneInformazioniTokenEnrichPDNDClientInfo(EsitoGestioneToken esitoGestioneToken, PolicyGestioneToken policyGestioneToken, 
  1906.             PdDContext pddContext, IProtocolFactory<?> protocolFactory, AbstractDatiInvocazione datiInvocazione,
  1907.             SecurityToken securityTokenForContext) throws CoreException, ProtocolException {
  1908.         
  1909.         if( 
  1910.                 (policyGestioneToken!=null && policyGestioneToken.getName()!=null) // dal nome della policy viene capito se e' attivo il recupero dei dati PDND
  1911.                 &&
  1912.                 (esitoGestioneToken!=null && esitoGestioneToken.getInformazioniToken()!=null && esitoGestioneToken.getInformazioniToken().getClientId()!=null) // il clientId serve per poter effettuare il recupero dei dati
  1913.                 &&
  1914.                 (datiInvocazione instanceof DatiInvocazionePortaApplicativa) // solo per erogazioni
  1915.                 &&
  1916.                 (org.openspcoop2.protocol.engine.constants.Costanti.MODIPA_PROTOCOL_NAME.equals(protocolFactory.getProtocol())) // solo per profilo modi
  1917.                 ) {
  1918.             OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  1919.             if(op2Properties.isGestoreChiaviPDNDretrieveClientInfoAfterVoucherPDNDValidation()) {
  1920.                 
  1921.                 IDSoggetto idSoggetto = null;
  1922.                 DatiInvocazionePortaApplicativa datiPA = (DatiInvocazionePortaApplicativa) datiInvocazione;
  1923.                 if(datiPA.getPa()!=null && datiPA.getPa().getTipoSoggettoProprietario()!=null && datiPA.getPa().getNomeSoggettoProprietario()!=null) {
  1924.                     idSoggetto = new IDSoggetto(datiPA.getPa().getTipoSoggettoProprietario(), datiPA.getPa().getNomeSoggettoProprietario());
  1925.                 }
  1926.                 else if(datiPA.getRequestInfo()!=null && datiPA.getRequestInfo().getIdentitaPdD()!=null) {
  1927.                     idSoggetto = datiPA.getRequestInfo().getIdentitaPdD();
  1928.                 }
  1929.                     
  1930.                 PDNDResolver pdndResolver = new PDNDResolver(pddContext, ModIUtils.getRemoteStoreConfig());
  1931.                 pdndResolver.enrichTokenInfo(datiInvocazione.getRequestInfo(), idSoggetto,
  1932.                         esitoGestioneToken.getInformazioniToken(), securityTokenForContext);
  1933.             }
  1934.         }
  1935.         
  1936.     }
  1937.     
  1938.     static void validazioneInformazioniTokenHeader(String jsonHeader, PolicyGestioneToken policyGestioneToken) throws TokenException {
  1939.         
  1940.         if(policyGestioneToken.isValidazioneJWTHeader()) {
  1941.             
  1942.             try {
  1943.             
  1944.                 JSONUtils jsonUtils = JSONUtils.getInstance();
  1945.                 if(jsonUtils.isJson(jsonHeader)) {
  1946.                     JsonNode root = jsonUtils.getAsNode(jsonHeader);
  1947.                     Map<String, Serializable> readClaims = jsonUtils.convertToSimpleMap(root);
  1948.                     
  1949.                     validazioneInformazioniTokenHeader(readClaims, policyGestioneToken.getValidazioneJWTHeaderTyp(), Claims.JSON_WEB_TOKEN_RFC_7515_TYPE);
  1950.                     
  1951.                     validazioneInformazioniTokenHeader(readClaims, policyGestioneToken.getValidazioneJWTHeaderCty(), Claims.JSON_WEB_TOKEN_RFC_7515_CONTENT_TYPE);
  1952.                     
  1953.                     validazioneInformazioniTokenHeader(readClaims, policyGestioneToken.getValidazioneJWTHeaderAlg(), Claims.JSON_WEB_TOKEN_RFC_7515_ALGORITHM);
  1954.                 }   
  1955.                 
  1956.             }catch(Exception e) {
  1957.                 throw new TokenException("JWT header validation failed; "+e.getMessage(),e);
  1958.             }
  1959.             
  1960.         }
  1961.         
  1962.     }
  1963.     
  1964.     private static void validazioneInformazioniTokenHeader(Map<String, Serializable> readClaims, List<String> expectedValues, String claim) throws TokenException {
  1965.         if(expectedValues!=null && !expectedValues.isEmpty()) {
  1966.             String v = null;
  1967.             if(readClaims!=null && !readClaims.isEmpty()) {
  1968.                 v = TokenUtilities.getClaimAsString(readClaims,claim);
  1969.             }
  1970.             if(v==null || StringUtils.isEmpty(v)) {
  1971.                 throw new TokenException("Expected claim '"+claim+"' not found");
  1972.             }
  1973.             boolean find = false;
  1974.             for (String vCheck : expectedValues) {
  1975.                 if(v.equalsIgnoreCase(vCheck)) {
  1976.                     find = true;
  1977.                     break;
  1978.                 }
  1979.             }
  1980.             if(!find) {
  1981.                 throw new TokenException("Claim '"+claim+"' with invalid value '"+v+"'");
  1982.             }
  1983.         }
  1984.     }
  1985.     
  1986.     static String buildPrefixCacheKeyValidazione(String policy, String funzione) {
  1987.         StringBuilder bf = new StringBuilder(funzione);
  1988.         bf.append("_");
  1989.         bf.append(policy);
  1990.         bf.append("_");
  1991.         return bf.toString();
  1992.     }
  1993.     static String buildCacheKeyValidazione(String policy, String funzione, boolean portaDelegata, String token) {
  1994.         StringBuilder bf = new StringBuilder();
  1995.         bf.append(buildPrefixCacheKeyValidazione(policy, funzione));
  1996.         if(portaDelegata){
  1997.             bf.append("PD");
  1998.         }
  1999.         else {
  2000.             bf.append("PA");
  2001.         }
  2002.         bf.append("_");
  2003.         bf.append(token);
  2004.         return bf.toString();
  2005.     }
  2006.     
  2007.     static HttpResponse http(Logger log, PolicyGestioneToken policyGestioneToken, HTTP_TYPE httpType, 
  2008.             DynamicDiscovery dynamicDiscovery, String token,
  2009.             PdDContext pddContext, IProtocolFactory<?> protocolFactory, 
  2010.             IState state, boolean delegata, String idModulo, PortaApplicativa pa, PortaDelegata pd,
  2011.             IDSoggetto idDominio, IDServizio idServizio,
  2012.             Busta busta, RequestInfo requestInfo) throws Exception {
  2013.         
  2014.         // *** Raccola Parametri ***
  2015.         
  2016.         Map<String, Object> dynamicMap = TokenUtilities.buildDynamicMap(busta, requestInfo, pddContext, log);
  2017.         
  2018.         String endpoint = null;
  2019.         String prefixConnettore = null;
  2020.         boolean introspectionService = false;
  2021.         boolean userInfoService = false;
  2022.         switch (httpType) {
  2023.         case DYNAMIC_DISCOVERY:
  2024.             endpoint = policyGestioneToken.getDynamicDiscoveryEndpoint();
  2025.             if(endpoint!=null && !"".equals(endpoint)) {
  2026.                 endpoint = DynamicUtils.convertDynamicPropertyValue("endpoint.gwt", endpoint, dynamicMap, pddContext);  
  2027.             }
  2028.             prefixConnettore = "[EndpointDynamicDiscovery: "+endpoint+"] ";
  2029.             break;
  2030.         case INTROSPECTION:
  2031.             if(policyGestioneToken.isDynamicDiscovery()) {
  2032.                 check(dynamicDiscovery);
  2033.                 endpoint = dynamicDiscovery.getIntrospectionEndpoint();
  2034.                 if(endpoint!=null && !"".equals(endpoint)) {
  2035.                     endpoint = DynamicUtils.convertDynamicPropertyValue("endpoint.gwt", endpoint, dynamicMap, pddContext);  
  2036.                 }
  2037.                 if(endpoint==null || StringUtils.isEmpty(endpoint)) {
  2038.                     throw new TokenException("DynamicDiscovery.introspectionEndpoint undefined");
  2039.                 }
  2040.             }
  2041.             else {
  2042.                 endpoint = policyGestioneToken.getIntrospectionEndpoint();
  2043.             }
  2044.             prefixConnettore = "[EndpointIntrospection: "+endpoint+"] ";    
  2045.             introspectionService = true;
  2046.             break;
  2047.         case USER_INFO:
  2048.             if(policyGestioneToken.isDynamicDiscovery()) {
  2049.                 check(dynamicDiscovery);
  2050.                 endpoint = dynamicDiscovery.getUserinfoEndpoint();
  2051.                 if(endpoint!=null && !"".equals(endpoint)) {
  2052.                     endpoint = DynamicUtils.convertDynamicPropertyValue("endpoint.gwt", endpoint, dynamicMap, pddContext);  
  2053.                 }
  2054.                 if(endpoint==null || StringUtils.isEmpty(endpoint)) {
  2055.                     throw new TokenException("DynamicDiscovery.userinfoEndpoint undefined");
  2056.                 }
  2057.             }
  2058.             else {
  2059.                 endpoint = policyGestioneToken.getUserInfoEndpoint();
  2060.             }
  2061.             prefixConnettore = "[EndpointUserInfo: "+endpoint+"] ";     
  2062.             userInfoService = true;
  2063.             break;
  2064.         }
  2065.         
  2066.         TipoTokenRequest tipoTokenRequest = null;
  2067.         String positionTokenName = null;
  2068.         if(introspectionService) {
  2069.             tipoTokenRequest = policyGestioneToken.getIntrospectionTipoTokenRequest();  
  2070.         }
  2071.         else if(userInfoService) {
  2072.             tipoTokenRequest = policyGestioneToken.getUserInfoTipoTokenRequest();       
  2073.         }
  2074.         if(tipoTokenRequest!=null) {
  2075.             switch (tipoTokenRequest) {
  2076.             case authorization:
  2077.                 break;
  2078.             case header:
  2079.                 if(introspectionService) {
  2080.                     positionTokenName = policyGestioneToken.getIntrospectionTipoTokenRequestHeaderName();
  2081.                 }else {
  2082.                     positionTokenName = policyGestioneToken.getUserInfoTipoTokenRequestHeaderName();
  2083.                 }
  2084.                 break;
  2085.             case url:
  2086.                 if(introspectionService) {
  2087.                     positionTokenName = policyGestioneToken.getIntrospectionTipoTokenRequestUrlPropertyName();
  2088.                 }else {
  2089.                     positionTokenName = policyGestioneToken.getUserInfoTipoTokenRequestUrlPropertyName();
  2090.                 }
  2091.                 break;
  2092.             case form:
  2093.                 if(introspectionService) {
  2094.                     positionTokenName = policyGestioneToken.getIntrospectionTipoTokenRequestFormPropertyName();
  2095.                 }else {
  2096.                     positionTokenName = policyGestioneToken.getUserInfoTipoTokenRequestFormPropertyName();
  2097.                 }
  2098.                 break;
  2099.             }
  2100.         }
  2101.         if(positionTokenName!=null && !"".equals(positionTokenName)) {
  2102.             positionTokenName = DynamicUtils.convertDynamicPropertyValue("positionTokenName.gwt", positionTokenName, dynamicMap, pddContext);   
  2103.         }
  2104.         
  2105.         String contentType = null;
  2106.         if(introspectionService || userInfoService) {
  2107.             if(introspectionService) {
  2108.                 contentType = policyGestioneToken.getIntrospectionContentType();
  2109.             }else {
  2110.                 contentType = policyGestioneToken.getUserInfoContentType();
  2111.             }
  2112.         }
  2113.         if(contentType!=null && !"".equals(contentType)) {
  2114.             contentType = DynamicUtils.convertDynamicPropertyValue("contentType.gwt", contentType, dynamicMap, pddContext); 
  2115.         }
  2116.         
  2117.         HttpRequestMethod httpMethod = null;
  2118.         switch (httpType) {
  2119.         case DYNAMIC_DISCOVERY:
  2120.             httpMethod = HttpRequestMethod.GET;
  2121.             break;
  2122.         case INTROSPECTION:
  2123.             httpMethod = policyGestioneToken.getIntrospectionHttpMethod();
  2124.             break;
  2125.         case USER_INFO:
  2126.             httpMethod = policyGestioneToken.getUserInfoHttpMethod();
  2127.             break;
  2128.         }
  2129.         
  2130.         
  2131.         
  2132.         // Nell'endpoint config ci finisce i timeout e la configurazione proxy
  2133.         Properties endpointConfig = policyGestioneToken.getProperties().get(Costanti.POLICY_ENDPOINT_CONFIG);
  2134.         resolveDynamicProperyValues(endpointConfig, dynamicMap, pddContext);
  2135.         if(endpointConfig.containsKey(CostantiConnettori.CONNETTORE_HTTP_PROXY_HOSTNAME)) {
  2136.             String hostProxy = endpointConfig.getProperty(CostantiConnettori.CONNETTORE_HTTP_PROXY_HOSTNAME);
  2137.             String portProxy = endpointConfig.getProperty(CostantiConnettori.CONNETTORE_HTTP_PROXY_PORT);
  2138.             prefixConnettore = prefixConnettore+GestoreToken.getMessageViaProxy(hostProxy, portProxy);
  2139.         }
  2140.         
  2141.         boolean https = false;
  2142.         if(!https) {
  2143.             switch (httpType) {
  2144.             case DYNAMIC_DISCOVERY:
  2145.                 https = policyGestioneToken.isEndpointHttps(false, false);
  2146.                 break;
  2147.             case INTROSPECTION:
  2148.                 https = policyGestioneToken.isEndpointHttps(true, false);
  2149.                 break;
  2150.             case USER_INFO:
  2151.                 https = policyGestioneToken.isEndpointHttps(false, true);
  2152.                 break;
  2153.             }
  2154.         }
  2155.         boolean httpsClient = false;
  2156.         Properties sslConfig = null;
  2157.         Properties sslClientConfig = null;
  2158.         if(https) {
  2159.             sslConfig = policyGestioneToken.getProperties().get(Costanti.POLICY_ENDPOINT_SSL_CONFIG);
  2160.             resolveDynamicProperyValues(sslConfig, dynamicMap, pddContext);
  2161.             if(introspectionService || userInfoService) {
  2162.                 if(introspectionService) {
  2163.                     httpsClient = policyGestioneToken.isIntrospectionHttpsAuthentication();
  2164.                 }else {
  2165.                     httpsClient = policyGestioneToken.isUserInfoHttpsAuthentication();
  2166.                 }
  2167.             }
  2168.             if(httpsClient) {
  2169.                 sslClientConfig = policyGestioneToken.getProperties().get(Costanti.POLICY_ENDPOINT_SSL_CLIENT_CONFIG);
  2170.                 TokenUtilities.injectSameKeystoreForHttpsClient(sslConfig, sslClientConfig);
  2171.                 resolveDynamicProperyValues(sslClientConfig, dynamicMap, pddContext);
  2172.             }
  2173.         }
  2174.         
  2175.         boolean basic = false;
  2176.         String username = null;
  2177.         String password = null;
  2178.         if(introspectionService || userInfoService) {
  2179.             if(introspectionService) {
  2180.                 basic = policyGestioneToken.isIntrospectionBasicAuthentication();
  2181.             }else {
  2182.                 basic = policyGestioneToken.isUserInfoBasicAuthentication();
  2183.             }
  2184.         }
  2185.         if(basic) {
  2186.             if(introspectionService) {
  2187.                 username = policyGestioneToken.getIntrospectionBasicAuthenticationUsername();
  2188.                 password = policyGestioneToken.getIntrospectionBasicAuthenticationPassword();
  2189.             }
  2190.             else {
  2191.                 username = policyGestioneToken.getUserInfoBasicAuthenticationUsername();
  2192.                 password = policyGestioneToken.getUserInfoBasicAuthenticationPassword();
  2193.             }
  2194.             if(username!=null && !"".equals(username)) {
  2195.                 username = DynamicUtils.convertDynamicPropertyValue("username.gwt", username, dynamicMap, pddContext);  
  2196.             }
  2197.             if(password!=null && !"".equals(password)) {
  2198.                 password = DynamicUtils.convertDynamicPropertyValue("password.gwt", password, dynamicMap, pddContext);  
  2199.             }
  2200.         }
  2201.         
  2202.         boolean bearer = false;
  2203.         String bearerToken = null;
  2204.         if(introspectionService || userInfoService) {
  2205.             if(introspectionService) {
  2206.                 bearer = policyGestioneToken.isIntrospectionBearerAuthentication();
  2207.             }else {
  2208.                 bearer = policyGestioneToken.isUserInfoBearerAuthentication();
  2209.             }
  2210.         }
  2211.         if(bearer) {
  2212.             if(introspectionService) {
  2213.                 bearerToken = policyGestioneToken.getIntrospectionBeareAuthenticationToken();
  2214.             }
  2215.             else {
  2216.                 bearerToken = policyGestioneToken.getUserInfoBeareAuthenticationToken();
  2217.             }
  2218.             if(bearerToken!=null && !"".equals(bearerToken)) {
  2219.                 bearerToken = DynamicUtils.convertDynamicPropertyValue("bearerToken.gwt", bearerToken, dynamicMap, pddContext); 
  2220.             }
  2221.         }
  2222.         
  2223.         
  2224.         
  2225.         // *** Definizione Connettore ***
  2226.         
  2227.         ConnettoreMsg connettoreMsg = new ConnettoreMsg();
  2228.         ConnettoreBaseHTTP connettore = null;
  2229.         if(https) {
  2230.             connettoreMsg.setTipoConnettore(TipiConnettore.HTTPS.getNome());
  2231.             connettore = new ConnettoreHTTPS();
  2232.         }
  2233.         else {
  2234.             connettoreMsg.setTipoConnettore(TipiConnettore.HTTP.getNome());
  2235.             connettore = new ConnettoreHTTP();
  2236.         }
  2237.         connettoreMsg.setIdModulo(idModulo);
  2238.         connettoreMsg.setState(state);
  2239.         PolicyTimeoutConfig policyConfig = new PolicyTimeoutConfig();
  2240.         switch (httpType) {
  2241.         case DYNAMIC_DISCOVERY:
  2242.             policyConfig.setPolicyValidazioneDynamicDiscovery(policyGestioneToken.getName());   
  2243.             break;
  2244.         case INTROSPECTION:
  2245.             policyConfig.setPolicyValidazioneIntrospection(policyGestioneToken.getName());
  2246.             break;
  2247.         case USER_INFO:
  2248.             policyConfig.setPolicyValidazioneUserInfo(policyGestioneToken.getName());
  2249.             break;
  2250.         }
  2251.         connettoreMsg.setPolicyTimeoutConfig(policyConfig);
  2252.         
  2253.         ForwardProxy forwardProxy = TokenUtilities.getForwardProxy(policyGestioneToken,
  2254.                 requestInfo, state, delegata,
  2255.                 idDominio, idServizio);
  2256.         if(forwardProxy!=null && forwardProxy.isEnabled() && forwardProxy.getConfigToken()!=null) {
  2257.             boolean enabled = false;
  2258.             switch (httpType) {
  2259.             case DYNAMIC_DISCOVERY:
  2260.                 enabled = forwardProxy.getConfigToken().isTokenDynamicDiscoveryEnabled();
  2261.                 break;
  2262.             case INTROSPECTION:
  2263.                 enabled = forwardProxy.getConfigToken().isTokenIntrospectionEnabled();
  2264.                 break;
  2265.             case USER_INFO:
  2266.                 enabled = forwardProxy.getConfigToken().isTokenUserInfoEnabled();
  2267.                 break;
  2268.             }
  2269.             if(enabled) {
  2270.                 connettoreMsg.setForwardProxy(forwardProxy);
  2271.             }
  2272.         }
  2273.         
  2274.         connettore.setForceDisable_proxyPassReverse(true);
  2275.         connettore.init(pddContext, protocolFactory);
  2276.         connettore.setRegisterSendIntoContext(false);
  2277.         
  2278.         if(basic){
  2279.             InvocazioneCredenziali credenziali = new InvocazioneCredenziali();
  2280.             credenziali.setUser(username);
  2281.             credenziali.setPassword(password);
  2282.             connettoreMsg.setCredenziali(credenziali);
  2283.         }
  2284.         
  2285.         connettoreMsg.setConnectorProperties(new java.util.HashMap<>());
  2286.         connettoreMsg.getConnectorProperties().put(CostantiConnettori.CONNETTORE_LOCATION, endpoint);
  2287.         boolean debug = false;
  2288.         OpenSPCoop2Properties properties = OpenSPCoop2Properties.getInstance();
  2289.         switch (httpType) {
  2290.         case DYNAMIC_DISCOVERY:
  2291.             debug = properties.isGestioneTokenDynamicDiscoveryDebug();
  2292.             break;
  2293.         case INTROSPECTION:
  2294.             debug = properties.isGestioneTokenIntrospectionDebug(); 
  2295.             break;
  2296.         case USER_INFO:
  2297.             debug = properties.isGestioneTokenUserInfoDebug();
  2298.             break;
  2299.         }
  2300.         if(debug) {
  2301.             connettoreMsg.getConnectorProperties().put(CostantiConnettori.CONNETTORE_DEBUG, true+"");
  2302.         }
  2303.         connettoreMsg.getConnectorProperties().put(CostantiConnettori.CONNETTORE_HTTP_DATA_TRANSFER_MODE, TransferLengthModes.CONTENT_LENGTH.getNome());
  2304.         GestoreToken.addProperties(connettoreMsg, endpointConfig);
  2305.         if(https) {
  2306.             GestoreToken.addProperties(connettoreMsg, sslConfig);
  2307.             if(httpsClient) {
  2308.                 GestoreToken.addProperties(connettoreMsg, sslClientConfig);
  2309.             }
  2310.         }
  2311.         
  2312.         byte[] content = null;
  2313.         
  2314.         TransportRequestContext transportRequestContext = new TransportRequestContext(log);
  2315.         if(httpMethod!=null) {
  2316.             transportRequestContext.setRequestType(httpMethod.name());
  2317.         }
  2318.         transportRequestContext.setHeaders(new HashMap<>());
  2319.         if(bearer) {
  2320.             String authorizationHeader = HttpConstants.AUTHORIZATION_PREFIX_BEARER+bearerToken;
  2321.             TransportUtils.setHeader(transportRequestContext.getHeaders(),HttpConstants.AUTHORIZATION, authorizationHeader);
  2322.         }
  2323.         if(contentType!=null) {
  2324.             TransportUtils.setHeader(transportRequestContext.getHeaders(),HttpConstants.CONTENT_TYPE, contentType);
  2325.         }
  2326.         if(tipoTokenRequest!=null) {
  2327.             switch (tipoTokenRequest) {
  2328.             case authorization:
  2329.                 transportRequestContext.removeHeader(HttpConstants.AUTHORIZATION);
  2330.                 String authorizationHeader = HttpConstants.AUTHORIZATION_PREFIX_BEARER+token;
  2331.                 TransportUtils.setHeader(transportRequestContext.getHeaders(),HttpConstants.AUTHORIZATION, authorizationHeader);
  2332.                 break;
  2333.             case header:
  2334.                 TransportUtils.setHeader(transportRequestContext.getHeaders(),positionTokenName, token);
  2335.                 break;
  2336.             case url:
  2337.                 transportRequestContext.setParameters(new HashMap<>());
  2338.                 TransportUtils.setParameter(transportRequestContext.getParameters(),positionTokenName, token);
  2339.                 break;
  2340.             case form:
  2341.                 transportRequestContext.removeHeader(HttpConstants.CONTENT_TYPE);
  2342.                 TransportUtils.setHeader(transportRequestContext.getHeaders(),HttpConstants.CONTENT_TYPE, HttpConstants.CONTENT_TYPE_X_WWW_FORM_URLENCODED);
  2343.                 content = (positionTokenName+"="+token).getBytes();
  2344.                 break;
  2345.             }
  2346.         }
  2347.         
  2348.         OpenSPCoop2MessageParseResult pr = OpenSPCoop2MessageFactory.getDefaultMessageFactory().createMessage(MessageType.BINARY, transportRequestContext, content);
  2349.         OpenSPCoop2Message msg = pr.getMessage_throwParseException();
  2350.         connettoreMsg.setRequestMessage(msg);
  2351.         connettoreMsg.setGenerateErrorWithConnectorPrefix(false);
  2352.         connettore.setHttpMethod(msg);
  2353.         connettore.setPa(pa);
  2354.         connettore.setPd(pd);
  2355.         
  2356.         ResponseCachingConfigurazione responseCachingConfigurazione = new ResponseCachingConfigurazione();
  2357.         responseCachingConfigurazione.setStato(StatoFunzionalita.DISABILITATO);
  2358.         boolean send = connettore.send(responseCachingConfigurazione, connettoreMsg);
  2359.         if(!send) {
  2360.             if(connettore.getEccezioneProcessamento()!=null) {
  2361.                 throw new TokenException(prefixConnettore+connettore.getErrore(), connettore.getEccezioneProcessamento());
  2362.             }
  2363.             else {
  2364.                 throw new TokenException(prefixConnettore+connettore.getErrore());
  2365.             }
  2366.         }
  2367.         
  2368.         OpenSPCoop2Message msgResponse = connettore.getResponse();
  2369.         ByteArrayOutputStream bout = null;
  2370.         if(msgResponse!=null) {
  2371.             bout = new ByteArrayOutputStream();
  2372.             if(msgResponse!=null) {
  2373.                 msgResponse.writeTo(bout, true);
  2374.             }
  2375.             bout.flush();
  2376.             bout.close();
  2377.         }
  2378.         
  2379.         HttpResponse httpResponse = new HttpResponse();
  2380.         httpResponse.setResultHTTPOperation(connettore.getCodiceTrasporto());
  2381.         
  2382.         if(connettore.getCodiceTrasporto() >= 200 &&  connettore.getCodiceTrasporto() < 299) {
  2383.             String msgSuccess = prefixConnettore+GestoreToken.getMessageConnettoreConnessioneSuccesso(connettore);
  2384.             if(bout!=null && bout.size()>0) {
  2385.                 log.debug(msgSuccess);
  2386.                 httpResponse.setContent(bout.toByteArray());
  2387.                 return httpResponse;
  2388.             }
  2389.             else {
  2390.                 throw new TokenException(msgSuccess+GestoreToken.CONNETTORE_RISPOSTA_NON_PERVENUTA);
  2391.             }
  2392.         }
  2393.         else {
  2394.             String msgError = prefixConnettore+GestoreToken.getMessageConnettoreConnessioneErrore(connettore);
  2395.             if(bout!=null && bout.size()>0) {
  2396.                 String e = msgError+": "+bout.toString();
  2397.                 log.debug(e);
  2398.                 httpResponse.setContent(bout.toByteArray());
  2399.                 return httpResponse;
  2400.             }
  2401.             else {
  2402.                 log.error(msgError);
  2403.                 throw new TokenException(msgError);
  2404.             }
  2405.         }
  2406.         
  2407.         
  2408.     }
  2409.     
  2410.     private static void resolveDynamicProperyValues(Properties p,
  2411.             Map<String, Object> dynamicMap, Context context) throws DynamicException {
  2412.         if(p!=null && !p.isEmpty()) {
  2413.             Enumeration<?> oKey = p.keys();
  2414.             while (oKey.hasMoreElements()) {
  2415.                 Object object = oKey.nextElement();
  2416.                 if(object instanceof String) {
  2417.                     String key = (String) object;
  2418.                     String value = p.getProperty(key);
  2419.                     if(value!=null && !"".equals(value) && value.contains("{") && value.contains("}")) {
  2420.                         value = DynamicUtils.convertDynamicPropertyValue(key+".gwt", value, dynamicMap, context);
  2421.                         p.put(key, value);
  2422.                     }           
  2423.                 }
  2424.             }
  2425.         }
  2426.     }

  2428.     static void check(DynamicDiscovery dynamicDiscovery) throws TokenException {
  2429.         if(dynamicDiscovery==null) {
  2430.             throw new TokenException("DynamicDiscovery information not found");
  2431.         }
  2432.         if(!dynamicDiscovery.isValid()) {
  2433.             throw new TokenException("DynamicDiscovery failed");
  2434.         }
  2435.     }
  2436.     
  2437. }

  2439. enum HTTP_TYPE {
  2440.     
  2441.     DYNAMIC_DISCOVERY, INTROSPECTION, USER_INFO
  2442.     
  2443. }
Created with JaCoCo 0.8.8.202204050719