GestoreTokenNegoziazioneUtilities.java

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

  21. package org.openspcoop2.pdd.core.token;

  23. import java.io.ByteArrayOutputStream;
  24. import java.net.URI;
  25. import java.security.cert.Certificate;
  26. import java.security.cert.X509Certificate;
  27. import java.util.Date;
  28. import java.util.Enumeration;
  29. import java.util.HashMap;
  30. import java.util.List;
  31. import java.util.Map;
  32. import java.util.Properties;

  34. import org.apache.commons.lang.StringUtils;
  35. import org.apache.cxf.rs.security.jose.jwk.JsonWebKeys;
  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.ResponseCachingConfigurazione;
  41. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  42. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  43. import org.openspcoop2.core.constants.CostantiConnettori;
  44. import org.openspcoop2.core.constants.TipiConnettore;
  45. import org.openspcoop2.core.constants.TipoPdD;
  46. import org.openspcoop2.core.constants.TransferLengthModes;
  47. import org.openspcoop2.core.id.IDGenericProperties;
  48. import org.openspcoop2.core.id.IDServizio;
  49. import org.openspcoop2.core.id.IDSoggetto;
  50. import org.openspcoop2.core.mvc.properties.provider.ProviderException;
  51. import org.openspcoop2.core.mvc.properties.provider.ProviderValidationException;
  52. import org.openspcoop2.message.OpenSPCoop2Message;
  53. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  54. import org.openspcoop2.message.OpenSPCoop2MessageParseResult;
  55. import org.openspcoop2.message.constants.MessageType;
  56. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  57. import org.openspcoop2.pdd.config.ForwardProxy;
  58. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  59. import org.openspcoop2.pdd.core.PdDContext;
  60. import org.openspcoop2.pdd.core.connettori.ConnettoreBaseHTTP;
  61. import org.openspcoop2.pdd.core.connettori.ConnettoreHTTP;
  62. import org.openspcoop2.pdd.core.connettori.ConnettoreHTTPS;
  63. import org.openspcoop2.pdd.core.connettori.ConnettoreMsg;
  64. import org.openspcoop2.pdd.core.controllo_traffico.PolicyTimeoutConfig;
  65. import org.openspcoop2.pdd.core.dynamic.DynamicMapBuilderUtils;
  66. import org.openspcoop2.pdd.core.token.parser.Claims;
  67. import org.openspcoop2.pdd.core.token.parser.ClaimsNegoziazione;
  68. import org.openspcoop2.pdd.core.token.parser.INegoziazioneTokenParser;
  69. import org.openspcoop2.protocol.sdk.Busta;
  70. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  71. import org.openspcoop2.protocol.sdk.state.IState;
  72. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  73. import org.openspcoop2.security.SecurityException;
  74. import org.openspcoop2.security.keystore.JWKSetStore;
  75. import org.openspcoop2.security.keystore.KeyPairStore;
  76. import org.openspcoop2.security.keystore.MerlinKeystore;
  77. import org.openspcoop2.security.keystore.cache.GestoreKeystoreCache;
  78. import org.openspcoop2.security.message.constants.SecurityConstants;
  79. import org.openspcoop2.utils.UtilsException;
  80. import org.openspcoop2.utils.certificate.KeyStore;
  81. import org.openspcoop2.utils.certificate.KeystoreParams;
  82. import org.openspcoop2.utils.certificate.KeystoreType;
  83. import org.openspcoop2.utils.certificate.byok.BYOKProvider;
  84. import org.openspcoop2.utils.certificate.byok.BYOKRequestParams;
  85. import org.openspcoop2.utils.date.DateManager;
  86. import org.openspcoop2.utils.id.UniqueIdentifierManager;
  87. import org.openspcoop2.utils.json.JSONUtils;
  88. import org.openspcoop2.utils.properties.PropertiesUtilities;
  89. import org.openspcoop2.utils.regexp.RegExpNotFoundException;
  90. import org.openspcoop2.utils.regexp.RegularExpressionEngine;
  91. import org.openspcoop2.utils.security.JOSESerialization;
  92. import org.openspcoop2.utils.security.JWSOptions;
  93. import org.openspcoop2.utils.security.JsonSignature;
  94. import org.openspcoop2.utils.security.JwtHeaders;
  95. import org.openspcoop2.utils.transport.TransportRequestContext;
  96. import org.openspcoop2.utils.transport.TransportUtils;
  97. import org.openspcoop2.utils.transport.http.HttpConstants;
  98. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  99. import org.openspcoop2.utils.transport.http.HttpResponse;
  100. import org.slf4j.Logger;

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

  104. /**     
  105.  * GestoreTokenNegoziazioneUtilities
  106.  *
  107.  * @author Poli Andrea (poli@link.it)
  108.  * @author $Author$
  109.  * @version $Rev$, $Date$
  110.  */
  111. public class GestoreTokenNegoziazioneUtilities {
  112.     
  113.     private GestoreTokenNegoziazioneUtilities() {}

  115.     static EsitoNegoziazioneToken endpointTokenEngine(boolean debug, Logger log, PolicyNegoziazioneToken policyNegoziazioneToken,
  116.             Busta busta, RequestInfo requestInfo, TipoPdD tipoPdD,
  117.             NegoziazioneTokenDynamicParameters dynamicParameters, IProtocolFactory<?> protocolFactory,
  118.             IState state, boolean delegata, String idModulo, PortaApplicativa pa, PortaDelegata pd,
  119.             IDSoggetto idDominio, IDServizio idServizio,
  120.             InformazioniNegoziazioneToken previousToken,
  121.             InformazioniNegoziazioneToken_DatiRichiesta datiRichiesta) {
  122.         
  123.         EsitoNegoziazioneToken esito = null;
  124.         
  125.         boolean refreshModeEnabled = false;
  126.         try {
  127.             if(policyNegoziazioneToken.isClientCredentialsGrant()) {
  128.                 refreshModeEnabled = OpenSPCoop2Properties.getInstance().isGestioneRetrieveTokenRefreshTokenGrantTypeClientCredentials();   
  129.                 if(datiRichiesta!=null) {
  130.                     datiRichiesta.setGrantType(Costanti.ID_RETRIEVE_TOKEN_METHOD_CLIENT_CREDENTIAL);
  131.                 }
  132.             }
  133.             else if(policyNegoziazioneToken.isUsernamePasswordGrant()) {
  134.                 refreshModeEnabled = OpenSPCoop2Properties.getInstance().isGestioneRetrieveTokenRefreshTokenGrantTypeUsernamePassword();    
  135.                 if(datiRichiesta!=null) {
  136.                     datiRichiesta.setGrantType(Costanti.ID_RETRIEVE_TOKEN_METHOD_USERNAME_PASSWORD);
  137.                 }
  138.             }
  139.             else if(policyNegoziazioneToken.isRfc7523x509Grant()) {
  140.                 refreshModeEnabled = OpenSPCoop2Properties.getInstance().isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523x509(); 
  141.                 if(datiRichiesta!=null) {
  142.                     datiRichiesta.setGrantType(Costanti.ID_RETRIEVE_TOKEN_METHOD_RFC_7523_X509);
  143.                 }
  144.             }
  145.             else if(policyNegoziazioneToken.isRfc7523ClientSecretGrant()) {
  146.                 refreshModeEnabled = OpenSPCoop2Properties.getInstance().isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523ClientSecret();
  147.                 if(datiRichiesta!=null) {
  148.                     datiRichiesta.setGrantType(Costanti.ID_RETRIEVE_TOKEN_METHOD_RFC_7523_CLIENT_SECRET);
  149.                 }
  150.             }
  151.             else if(policyNegoziazioneToken.isCustomGrant()) {
  152.                 refreshModeEnabled = OpenSPCoop2Properties.getInstance().isGestioneRetrieveTokenRefreshTokenGrantTypeCustom();  
  153.                 if(datiRichiesta!=null) {
  154.                     datiRichiesta.setGrantType(Costanti.ID_RETRIEVE_TOKEN_METHOD_CUSTOM);
  155.                 }
  156.             }
  157.         }catch(Exception t) {
  158.             log.error("Errore durante la comprensione della modalità di refresh: "+t.getMessage(),t);
  159.         }
  160.         
  161.         
  162.         if(refreshModeEnabled && previousToken!=null && previousToken.getRefreshToken()!=null) {
  163.             try {
  164.                 // Verico scadenza refresh
  165.                 if(previousToken.getRefreshExpiresIn()!=null) {
  166.                     Date now = DateManager.getDate();
  167.                     
  168.                     OpenSPCoop2Properties properties = OpenSPCoop2Properties.getInstance();
  169.                     now = updateNowForExpire("RefreshToken", now, previousToken.getRetrievedRefreshTokenIn(), previousToken.getRefreshExpiresIn(), 
  170.                             properties.getGestioneRetrieveTokenRefreshTokenBeforeExpirePercent(), properties.getGestioneRetrieveTokenRefreshTokenBeforeExpireSeconds());
  171.                     
  172.                     if(!now.before(previousToken.getRefreshExpiresIn())){
  173.                         // scaduto refresh token
  174.                         log.debug("Refresh token scaduto");
  175.                         refreshModeEnabled = false;
  176.                     }
  177.                 }
  178.                 if(refreshModeEnabled) {
  179.                     esito = invokeEndpointToken(debug, log, policyNegoziazioneToken,
  180.                             busta, requestInfo, tipoPdD,
  181.                             dynamicParameters, protocolFactory, 
  182.                             state, delegata, idModulo, pa, pd,
  183.                             idDominio, idServizio,
  184.                             refreshModeEnabled, previousToken,
  185.                             datiRichiesta);
  186.                     if(esito!=null && esito.isValido()) {
  187.                         // ricontrollo tutte le date (l'ho appena preso, dovrebbero essere buone) 
  188.                         boolean checkPerRinegoziazione = false;
  189.                         validazioneInformazioniNegoziazioneToken(checkPerRinegoziazione, esito,  
  190.                                 policyNegoziazioneToken.isSaveErrorInCache());
  191.                         if(datiRichiesta!=null) {
  192.                             datiRichiesta.setRefresh(true);
  193.                         }
  194.                         return esito;
  195.                     }
  196.                     if(esito==null || esito.getEccezioneProcessamento()==null) {
  197.                         throw new TokenException("token not refreshed");
  198.                     }
  199.                     else {
  200.                         throw new TokenException("token not refreshed: "+esito.getEccezioneProcessamento());
  201.                     }
  202.                 }
  203.             }catch(Exception t) {
  204.                 String msgError = "Refresh token failed: "+t.getMessage();
  205.                 log.error(msgError);
  206.             }
  207.         }
  208.         
  209.         if(datiRichiesta!=null) {
  210.             datiRichiesta.setRefresh(null);
  211.         }
  212.         return invokeEndpointToken(debug, log, policyNegoziazioneToken,
  213.                 busta, requestInfo, tipoPdD,
  214.                 dynamicParameters, protocolFactory, 
  215.                 state, delegata, idModulo, pa, pd,
  216.                 idDominio, idServizio,
  217.                 false, null,
  218.                 datiRichiesta);
  219.         
  220.     }
  221.     
  222.     
  223.     private static EsitoNegoziazioneToken invokeEndpointToken(boolean debug, Logger log, PolicyNegoziazioneToken policyNegoziazioneToken,
  224.             Busta busta, RequestInfo requestInfo, TipoPdD tipoPdD,
  225.             NegoziazioneTokenDynamicParameters dynamicParameters, IProtocolFactory<?> protocolFactory,
  226.             IState state, boolean delegata, String idModulo, PortaApplicativa pa, PortaDelegata pd,
  227.             IDSoggetto idDominio, IDServizio idServizio,
  228.             boolean refreshModeEnabled, InformazioniNegoziazioneToken previousToken,
  229.             InformazioniNegoziazioneToken_DatiRichiesta datiRichiesta) {
  230.     
  231.         EsitoNegoziazioneToken esitoNegoziazioneToken = new EsitoNegoziazioneToken();
  232.         
  233.         esitoNegoziazioneToken.setTokenInternalError();
  234.         
  235.         try{
  236.             String detailsError = null;
  237.             InformazioniNegoziazioneToken informazioniToken = null;
  238.             Exception eProcess = null;
  239.             
  240.             INegoziazioneTokenParser tokenParser = policyNegoziazioneToken.getNegoziazioneTokenParser();
  241.             
  242.             HttpResponse httpResponse = null;
  243.             Integer httpResponseCode = null;
  244.             byte[] risposta = null;
  245.             try {
  246.                 httpResponse = http(debug, log, policyNegoziazioneToken,
  247.                         busta, requestInfo, tipoPdD,
  248.                         dynamicParameters, protocolFactory, 
  249.                         state, delegata, idModulo, pa, pd,
  250.                         idDominio, idServizio,
  251.                         refreshModeEnabled, (refreshModeEnabled && previousToken!=null) ? previousToken.getRefreshToken() : null,
  252.                         datiRichiesta);
  253.                 risposta = httpResponse.getContent();
  254.                 httpResponseCode = httpResponse.getResultHTTPOperation();
  255.             }catch(Exception e) {
  256.                 detailsError = "(Errore di Connessione) "+ e.getMessage();
  257.                 eProcess = e;
  258.             }
  259.             
  260.             if(detailsError==null) {
  261.                 try {
  262.                     if(datiRichiesta!=null && datiRichiesta.getPrepareRequest()!=null) {
  263.                         datiRichiesta.setParseResponse(DateManager.getDate());
  264.                     }
  265.                     informazioniToken = new InformazioniNegoziazioneToken(datiRichiesta, httpResponseCode, new String(risposta),tokenParser,previousToken);
  266.                 }catch(Exception e) {
  267.                     detailsError = "Risposta del servizio di negoziazione token non valida: "+e.getMessage();
  268.                     eProcess = e;
  269.                 }
  270.             }
  271.                     
  272.             if(informazioniToken!=null && informazioniToken.isValid()) {
  273.                 esitoNegoziazioneToken.setTokenValido();
  274.                 esitoNegoziazioneToken.setInformazioniNegoziazioneToken(informazioniToken);
  275.                 esitoNegoziazioneToken.setToken(informazioniToken.getAccessToken());
  276.                 esitoNegoziazioneToken.setNoCache(false);
  277.             }
  278.             else {
  279.                 esitoNegoziazioneToken.setTokenValidazioneFallita();
  280.                 esitoNegoziazioneToken.setNoCache(!policyNegoziazioneToken.isSaveErrorInCache());
  281.                 esitoNegoziazioneToken.setEccezioneProcessamento(eProcess);
  282.                 if(detailsError!=null) {
  283.                     esitoNegoziazioneToken.setDetails(detailsError);    
  284.                 }
  285.                 else {
  286.                     esitoNegoziazioneToken.setDetails("AccessToken non recuperabile");  
  287.                 } 
  288.                 
  289.                 // comunque lo aggiungo per essere consultabile nei casi di errore
  290.                 if(OpenSPCoop2Properties.getInstance().isGestioneRetrieveTokenSaveTokenInfoRetrieveFailed()) {
  291.                     if(informazioniToken!=null) {
  292.                         if(httpResponseCode!=null) {
  293.                             informazioniToken.setHttpResponseCode(httpResponseCode+"");
  294.                         }
  295.                         informazioniToken.setErrorDetails(esitoNegoziazioneToken.getDetails());
  296.                     }
  297.                     else {
  298.                         informazioniToken = new InformazioniNegoziazioneToken(datiRichiesta,
  299.                                 esitoNegoziazioneToken.getDetails(), httpResponseCode, risposta);
  300.                     }
  301.                     esitoNegoziazioneToken.setInformazioniNegoziazioneToken(informazioniToken); 
  302.                 }
  303.             }
  304.             
  305.         }catch(Exception e){
  306.             esitoNegoziazioneToken.setTokenInternalError();
  307.             esitoNegoziazioneToken.setDetails(e.getMessage());
  308.             esitoNegoziazioneToken.setEccezioneProcessamento(e);
  309.         }
  310.         
  311.         if(datiRichiesta!=null && datiRichiesta.getPrepareRequest()!=null) {
  312.             datiRichiesta.setProcessComplete(DateManager.getDate());
  313.         }
  314.         return esitoNegoziazioneToken;
  315.     }
  316.     
  317.     static String buildPrefixCacheKeyNegoziazione(String policy, String funzione) {
  318.         StringBuilder bf = new StringBuilder(funzione);
  319.         bf.append("_");
  320.         bf.append(policy);
  321.         bf.append("_");
  322.         return bf.toString();
  323.     }
  324.     static String buildCacheKeyNegoziazione(String policy, String funzione, boolean portaDelegata, NegoziazioneTokenDynamicParameters dynamicParameters) {
  325.         StringBuilder bf = new StringBuilder();
  326.         bf.append(buildPrefixCacheKeyNegoziazione(policy, funzione));
  327.         if(portaDelegata){ // serve per non aver classcast exception nei risultati
  328.             bf.append("PD");
  329.         }
  330.         else {
  331.             bf.append("PA");
  332.         }
  333.         bf.append("_");
  334.         
  335.         String dynamicParametersKeyCache = dynamicParameters.toString("_", true);
  336.         bf.append(dynamicParametersKeyCache);
  337.         
  338.         return bf.toString();
  339.     }   
  340.     static void validazioneInformazioniNegoziazioneToken(boolean checkPerRinegoziazione, EsitoNegoziazioneToken esitoNegoziazioneToken, boolean saveErrorInCache) {
  341.         
  342.         Date now = DateManager.getDate();
  343.         
  344.         if(esitoNegoziazioneToken.isValido()) {
  345.             esitoNegoziazioneToken.setDateValide(true); // tanto le ricontrollo adesso
  346.         }
  347.         
  348.         if(esitoNegoziazioneToken.isValido() &&     
  349.             esitoNegoziazioneToken.getInformazioniNegoziazioneToken().getExpiresIn()!=null) {           
  350.                 
  351.             if(checkPerRinegoziazione) {
  352.                 
  353.                 OpenSPCoop2Properties properties = OpenSPCoop2Properties.getInstance();
  354.                 now = updateNowForExpire("NegoziazioneToken", now, esitoNegoziazioneToken.getInformazioniNegoziazioneToken().getRetrievedIn(), esitoNegoziazioneToken.getInformazioniNegoziazioneToken().getExpiresIn(), 
  355.                         properties.getGestioneRetrieveTokenRefreshTokenBeforeExpirePercent(), properties.getGestioneRetrieveTokenRefreshTokenBeforeExpireSeconds());
  356.                 
  357.             }
  358.             
  359.             /*
  360.              *  The lifetime in seconds of the access token.  For example, the value "3600" denotes that the access token will
  361.              * expire in one hour from the time the response was generated.
  362.              * If omitted, the authorization server SHOULD provide the expiration time via other means or document the default value. 
  363.              **/
  364.             if(!now.before(esitoNegoziazioneToken.getInformazioniNegoziazioneToken().getExpiresIn())){
  365.                 esitoNegoziazioneToken.setTokenScaduto();
  366.                 esitoNegoziazioneToken.setDateValide(false);
  367.                 esitoNegoziazioneToken.setDetails("AccessToken expired");   
  368.             }
  369.             
  370.         }
  371.             
  372.         if(!esitoNegoziazioneToken.isValido()) {
  373.             esitoNegoziazioneToken.setNoCache(!saveErrorInCache);
  374.         }
  375.     }
  376.     
  377.     static Map<String, Object> buildDynamicNegoziazioneTokenMap(Busta busta, 
  378.             RequestInfo requestInfo, PdDContext pddContext, Logger log) {
  379.         return TokenUtilities.buildDynamicMap(busta, 
  380.                 requestInfo, pddContext, log);
  381.     }
  382.     
  383.     private static HttpResponse http(boolean debug, Logger log, PolicyNegoziazioneToken policyNegoziazioneToken,
  384.             Busta busta, RequestInfo requestInfo, TipoPdD tipoPdD,
  385.             NegoziazioneTokenDynamicParameters dynamicParameters, IProtocolFactory<?> protocolFactory,
  386.             IState state, boolean delegata, String idModulo, PortaApplicativa pa, PortaDelegata pd,
  387.             IDSoggetto idDominio, IDServizio idServizio,
  388.             boolean refreshModeEnabled, String refreshToken,
  389.             InformazioniNegoziazioneToken_DatiRichiesta datiRichiesta) throws TokenException, ProviderException, ProviderValidationException, UtilsException, SecurityException {
  390.         
  391.         
  392.         // *** Raccola Parametri ***
  393.         
  394.         String endpoint = dynamicParameters.getEndpoint();
  395.         if(datiRichiesta!=null) {
  396.             datiRichiesta.setEndpoint(endpoint);
  397.         }
  398.         
  399.         HttpRequestMethod httpMethod = dynamicParameters.getHttpMethod();
  400.         
  401.         // Nell'endpoint config ci finisce i timeout e la configurazione proxy
  402.         Properties endpointConfig = policyNegoziazioneToken.getProperties().get(Costanti.POLICY_ENDPOINT_CONFIG);
  403.         
  404.         boolean https = policyNegoziazioneToken.isEndpointHttps();
  405.         boolean httpsClient = false;
  406.         Properties sslConfig = null;
  407.         Properties sslClientConfig = null;
  408.         if(https) {
  409.             sslConfig = policyNegoziazioneToken.getProperties().get(Costanti.POLICY_ENDPOINT_SSL_CONFIG);
  410.             httpsClient = policyNegoziazioneToken.isHttpsAuthentication();
  411.             if(httpsClient) {
  412.                 sslClientConfig = policyNegoziazioneToken.getProperties().get(Costanti.POLICY_ENDPOINT_SSL_CLIENT_CONFIG);
  413.                 TokenUtilities.injectSameKeystoreForHttpsClient(sslConfig, sslClientConfig);
  414.             }
  415.         }
  416.         
  417.         boolean basic = policyNegoziazioneToken.isBasicAuthentication();
  418.         boolean basicAsAuthorizationHeader = policyNegoziazioneToken.isBasicAuthenticationAsAuthorizationHeader();
  419.         String username = null;
  420.         String password = null;
  421.         if(basic) {
  422.             username = dynamicParameters.getBasicUsername();
  423.             password = dynamicParameters.getBasicPassword();
  424.             if(datiRichiesta!=null) {
  425.                 datiRichiesta.setClientId(username);
  426.             }
  427.         }
  428.         
  429.         boolean bearer = policyNegoziazioneToken.isBearerAuthentication();
  430.         String bearerToken = null;
  431.         if(bearer) {
  432.             bearerToken = dynamicParameters.getBearerToken();
  433.             if(datiRichiesta!=null) {
  434.                 datiRichiesta.setClientToken(bearerToken);
  435.             }
  436.         }
  437.         
  438.         
  439.         
  440.         // *** Definizione Connettore ***
  441.         
  442.         ConnettoreMsg connettoreMsg = new ConnettoreMsg();
  443.         ConnettoreBaseHTTP connettore = null;
  444.         if(https) {
  445.             connettoreMsg.setTipoConnettore(TipiConnettore.HTTPS.getNome());
  446.             connettore = new ConnettoreHTTPS();
  447.         }
  448.         else {
  449.             connettoreMsg.setTipoConnettore(TipiConnettore.HTTP.getNome());
  450.             connettore = new ConnettoreHTTP();
  451.         }
  452.         connettoreMsg.setIdModulo(idModulo);
  453.         connettoreMsg.setState(state);
  454.         PolicyTimeoutConfig policyConfig = new PolicyTimeoutConfig();
  455.         policyConfig.setPolicyNegoziazione(policyNegoziazioneToken.getName());
  456.         connettoreMsg.setPolicyTimeoutConfig(policyConfig);
  457.         
  458.         ForwardProxy forwardProxy = null;
  459.         ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(state);
  460.         if(configurazionePdDManager.isForwardProxyEnabled(requestInfo)) {
  461.             try {
  462.                 IDGenericProperties policy = new IDGenericProperties();
  463.                 policy.setTipologia(CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_RETRIEVE);
  464.                 policy.setNome(policyNegoziazioneToken.getName());
  465.                 if(delegata) {
  466.                     forwardProxy = configurazionePdDManager.getForwardProxyConfigFruizione(idDominio, idServizio, policy, requestInfo);
  467.                 }
  468.                 else {
  469.                     forwardProxy = configurazionePdDManager.getForwardProxyConfigErogazione(idDominio, idServizio, policy, requestInfo);
  470.                 }
  471.             }catch(Exception e) {
  472.                 throw new TokenException(GestoreToken.getMessageErroreGovWayProxy(e),e);
  473.             }
  474.         }
  475.         if(forwardProxy!=null && forwardProxy.isEnabled() && forwardProxy.getConfigToken()!=null && forwardProxy.getConfigToken().isTokenRetrieveEnabled()) {
  476.             connettoreMsg.setForwardProxy(forwardProxy);
  477.         }
  478.         
  479.         connettore.setForceDisable_proxyPassReverse(true);
  480.         connettore.init(dynamicParameters.getPddContext(), protocolFactory);
  481.         connettore.setRegisterSendIntoContext(false);
  482.         
  483.         if(basic && basicAsAuthorizationHeader){
  484.             InvocazioneCredenziali credenziali = new InvocazioneCredenziali();
  485.             credenziali.setUser(username);
  486.             credenziali.setPassword(password);
  487.             connettoreMsg.setCredenziali(credenziali);
  488.         }
  489.         
  490.         connettoreMsg.setConnectorProperties(new java.util.HashMap<>());
  491.         connettoreMsg.getConnectorProperties().put(CostantiConnettori.CONNETTORE_LOCATION, endpoint);
  492.         OpenSPCoop2Properties properties = OpenSPCoop2Properties.getInstance();
  493.         Boolean debugTramiteProperties = properties.getGestioneRetrieveTokenDebug();
  494.         if(debugTramiteProperties!=null) {
  495.             if(debugTramiteProperties) {
  496.                 connettoreMsg.getConnectorProperties().put(CostantiConnettori.CONNETTORE_DEBUG, true+"");
  497.             }
  498.         }
  499.         else if(debug) { // impostazione del connettore
  500.             connettoreMsg.getConnectorProperties().put(CostantiConnettori.CONNETTORE_DEBUG, true+"");
  501.         }
  502.         connettoreMsg.getConnectorProperties().put(CostantiConnettori.CONNETTORE_HTTP_DATA_TRANSFER_MODE, TransferLengthModes.CONTENT_LENGTH.getNome());
  503.         GestoreToken.addProperties(connettoreMsg, endpointConfig);
  504.         if(https) {
  505.             GestoreToken.addProperties(connettoreMsg, sslConfig);
  506.             if(httpsClient) {
  507.                 GestoreToken.addProperties(connettoreMsg, sslClientConfig);
  508.             }
  509.         }
  510.         
  511.         
  512.         TransportRequestContext transportRequestContext = new TransportRequestContext(log);
  513.         transportRequestContext.setRequestType(httpMethod.name());
  514.         transportRequestContext.setHeaders(new HashMap<>());
  515.         if(bearer) {
  516.             String authorizationHeader = HttpConstants.AUTHORIZATION_PREFIX_BEARER+bearerToken;
  517.             TransportUtils.setHeader(transportRequestContext.getHeaders(),HttpConstants.AUTHORIZATION, authorizationHeader);
  518.         }
  519.         
  520.         Map<String, List<String>> pContent = new HashMap<>();
  521.         boolean custom = false;
  522.         if(refreshModeEnabled) {
  523.             TransportUtils.setParameter(pContent,ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_GRANT_TYPE, ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_GRANT_TYPE_REFRESH_TOKEN);
  524.             TransportUtils.setParameter(pContent,ClaimsNegoziazione.OAUTH2_RFC_6749_REFRESH_TOKEN, refreshToken);
  525.         }
  526.         else if(policyNegoziazioneToken.isClientCredentialsGrant()) {
  527.             TransportUtils.setParameter(pContent,ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_GRANT_TYPE, ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_GRANT_TYPE_CLIENT_CREDENTIALS_GRANT);
  528.         }
  529.         else if(policyNegoziazioneToken.isRfc7523x509Grant() || policyNegoziazioneToken.isRfc7523ClientSecretGrant()) {
  530.             TransportUtils.setParameter(pContent,ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_GRANT_TYPE, ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_GRANT_TYPE_CLIENT_CREDENTIALS_GRANT);
  531.             TransportUtils.setParameter(pContent,ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_CLIENT_ASSERTION_TYPE, ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_CLIENT_ASSERTION_TYPE_RFC_7523);
  532.         }
  533.         else if(policyNegoziazioneToken.isUsernamePasswordGrant()) {
  534.             TransportUtils.setParameter(pContent,ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_GRANT_TYPE, ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_GRANT_TYPE_RESOURCE_OWNER_PASSWORD_CREDENTIALS_GRANT);
  535.         }
  536.         else if(policyNegoziazioneToken.isCustomGrant()) {
  537.             custom = true;
  538.         }
  539.         else {
  540.             throw new TokenException("Nessuna modalità definita");
  541.         }
  542.         
  543.         transportRequestContext.removeHeader(HttpConstants.CONTENT_TYPE);
  544.         String contentType = null;
  545.         if(custom) {
  546.             contentType = dynamicParameters.getHttpContentType();
  547.             if(contentType!=null && StringUtils.isNotEmpty(contentType)) {
  548.                 TransportUtils.setHeader(transportRequestContext.getHeaders(),HttpConstants.CONTENT_TYPE, contentType);
  549.             }
  550.         }
  551.         else {
  552.             contentType = HttpConstants.CONTENT_TYPE_X_WWW_FORM_URLENCODED;
  553.             TransportUtils.setHeader(transportRequestContext.getHeaders(),HttpConstants.CONTENT_TYPE, contentType);
  554.         }
  555.         
  556.         if(!custom && basic && !basicAsAuthorizationHeader){
  557.             TransportUtils.setParameter(pContent,ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_CLIENT_ID, username);
  558.             TransportUtils.setParameter(pContent,ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_CLIENT_SECRET, password);
  559.         }
  560.         
  561.         if(policyNegoziazioneToken.isUsernamePasswordGrant()) {
  562.             String usernamePasswordGrantUsername = dynamicParameters.getUsernamePasswordGrantUsername();
  563.             String usernamePasswordGrantPassword = dynamicParameters.getUsernamePasswordGrantPassword();
  564.             TransportUtils.setParameter(pContent,ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_USERNAME, usernamePasswordGrantUsername);
  565.             TransportUtils.setParameter(pContent,ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_PASSWORD, usernamePasswordGrantPassword);
  566.             if(datiRichiesta!=null) {
  567.                 datiRichiesta.setUsername(usernamePasswordGrantUsername);
  568.             }
  569.         }
  570.         
  571.         if(policyNegoziazioneToken.isRfc7523x509Grant() || policyNegoziazioneToken.isRfc7523ClientSecretGrant()) {
  572.             String jwt = buildJwt(policyNegoziazioneToken,
  573.                     busta, tipoPdD,
  574.                     dynamicParameters,
  575.                     protocolFactory, requestInfo);
  576.             String signedJwt = signJwt(policyNegoziazioneToken, jwt, contentType, dynamicParameters, 
  577.                     busta, requestInfo, log);
  578.             TransportUtils.setParameter(pContent,ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_CLIENT_ASSERTION, signedJwt);
  579.             if(datiRichiesta!=null) {
  580.                 boolean infoNormalizzate = properties.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoTransazioniRegistrazioneInformazioniNormalizzate();
  581.                 datiRichiesta.setJwtClientAssertion(new InformazioniJWTClientAssertion(log, signedJwt, infoNormalizzate));
  582.             }
  583.         }
  584.         
  585.         if(!custom) {
  586.             List<String> scopes = policyNegoziazioneToken.getScopes(dynamicParameters);
  587.             if(scopes!=null && !scopes.isEmpty()) {
  588.                 StringBuilder bf = new StringBuilder();
  589.                 for (String scope : scopes) {
  590.                     if(bf.length()>0) {
  591.                         bf.append(" ");
  592.                     }
  593.                     bf.append(scope);
  594.                 }
  595.                 if(bf.length()>0) {
  596.                     TransportUtils.setParameter(pContent,ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_SCOPE, bf.toString());
  597.                     if(datiRichiesta!=null) {
  598.                         datiRichiesta.setScope(scopes);
  599.                     }
  600.                 }
  601.             }
  602.             
  603.             String aud = dynamicParameters.getAudience();
  604.             if(aud!=null && !"".equals(aud)) {
  605.                 TransportUtils.setParameter(pContent,ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_AUDIENCE, aud);
  606.                 if(datiRichiesta!=null) {
  607.                     datiRichiesta.setAudience(aud);
  608.                 }
  609.             }
  610.         }
  611.         
  612.         // indicazione se siamo in una token policy PDND
  613.         boolean pdnd = isTokenPolicyVersoPDND(policyNegoziazioneToken, OpenSPCoop2Properties.getInstance(), protocolFactory);
  614.         if(pdnd) {
  615.             String formClientId = dynamicParameters.getFormClientId();
  616.             if(formClientId==null) {
  617.                 OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  618.                 String nomeSoggettoInterno = getNomeSoggettoInterno(busta, tipoPdD, 
  619.                         protocolFactory, requestInfo, 
  620.                         op2Properties);
  621.                 if(op2Properties.isGestioneRetrieveTokenPdndDatiRichiestaForceClientId(protocolFactory!=null ? protocolFactory.getProtocol() : null, nomeSoggettoInterno)) {
  622.                     formClientId = dynamicParameters.getSignedJwtClientId();
  623.                 }
  624.             }
  625.             if(formClientId!=null && !"".equals(formClientId) && !Costanti.POLICY_RETRIEVE_TOKEN_JWT_CLAIM_UNDEFINED.equals(formClientId)) {
  626.                 TransportUtils.setParameter(pContent,Costanti.PDND_OAUTH2_RFC_6749_REQUEST_CLIENT_ID, formClientId);
  627.                 if(datiRichiesta!=null && datiRichiesta.getClientId()==null) { // dovrebbe essere null poiche' il tipo PDND non e' abilitabile per il tipo clientId/Secret
  628.                     datiRichiesta.setClientId(formClientId);
  629.                 }
  630.             }
  631.             
  632.             String formResource = dynamicParameters.getFormResource();
  633.             if(formResource!=null && !"".equals(formResource) && !Costanti.POLICY_RETRIEVE_TOKEN_JWT_CLAIM_UNDEFINED.equals(formResource)) {
  634.                 TransportUtils.setParameter(pContent,Costanti.PDND_OAUTH2_RFC_6749_REQUEST_RESOURCE, formResource);
  635.             }
  636.         }
  637.         
  638.         String parameters = dynamicParameters.getParameters();
  639.         if(!custom && parameters!=null && !"".equals(parameters)) {
  640.             Properties convertTextToProperties = PropertiesUtilities.convertTextToProperties(parameters);
  641.             if(convertTextToProperties!=null && !convertTextToProperties.isEmpty()) {
  642.                 Map<String, String> mapParameters = new HashMap<>();
  643.                 Enumeration<Object> keys = convertTextToProperties.keys();
  644.                 while (keys.hasMoreElements()) {
  645.                     String nome = (String) keys.nextElement();
  646.                     if(nome!=null && !"".equals(nome)) {
  647.                         String valore = convertTextToProperties.getProperty(nome);
  648.                         if(valore!=null) {
  649.                             TransportUtils.setParameter(pContent, nome, valore);
  650.                             mapParameters.put(nome, valore);
  651.                         }
  652.                     }
  653.                 }
  654.                 if(datiRichiesta!=null && !mapParameters.isEmpty()) {
  655.                     datiRichiesta.setParameters(mapParameters);
  656.                 }
  657.             }
  658.         }
  659.         
  660.         String httpHeaders = dynamicParameters.getHttpHeaders();
  661.         if(httpHeaders!=null && !"".equals(httpHeaders)) {
  662.             Properties convertTextToProperties = PropertiesUtilities.convertTextToProperties(httpHeaders);
  663.             if(convertTextToProperties!=null && !convertTextToProperties.isEmpty()) {
  664.                 Map<String, String> mapHttpHeaders = new HashMap<>();
  665.                 Enumeration<Object> keys = convertTextToProperties.keys();
  666.                 while (keys.hasMoreElements()) {
  667.                     String nome = (String) keys.nextElement();
  668.                     if(nome!=null && !"".equals(nome)) {
  669.                         String valore = convertTextToProperties.getProperty(nome);
  670.                         if(valore!=null) {
  671.                             TransportUtils.setHeader(transportRequestContext.getHeaders(),nome, valore);
  672.                             mapHttpHeaders.put(nome, valore);
  673.                         }
  674.                     }
  675.                 }
  676.                 if(datiRichiesta!=null && !mapHttpHeaders.isEmpty()) {
  677.                     datiRichiesta.setHttpHeaders(mapHttpHeaders);
  678.                 }
  679.             }
  680.         }

  682.         String prefixUrl = "PREFIX?";
  683.         byte [] content = null;
  684.         if(custom) {
  685.             String contentString = dynamicParameters.getHttpPayload();
  686.             if(contentString!=null && StringUtils.isNotEmpty(contentString)) {
  687.                 content = contentString.getBytes();
  688.                 connettoreMsg.forceSendContent();
  689.             }
  690.         }
  691.         else {
  692.             String contentString = TransportUtils.buildUrlWithParameters(pContent, prefixUrl , log);
  693.             contentString = contentString.substring(prefixUrl.length());
  694.             if(contentString.startsWith("&") && contentString.length()>1) {
  695.                 contentString = contentString.substring(1);
  696.             }
  697.             content = contentString.getBytes();
  698.         }
  699.             
  700.         try {
  701.             OpenSPCoop2MessageParseResult pr = OpenSPCoop2MessageFactory.getDefaultMessageFactory().createMessage(MessageType.BINARY, transportRequestContext, content);
  702.             OpenSPCoop2Message msg = pr.getMessage_throwParseException();
  703.             connettoreMsg.setRequestMessage(msg);
  704.             connettoreMsg.setGenerateErrorWithConnectorPrefix(false);
  705.                         
  706.             connettore.setHttpMethod(msg);
  707.             connettore.setPa(pa);
  708.             connettore.setPd(pd);
  709.         }catch(Exception e) {
  710.             throw new TokenException(e.getMessage(),e);
  711.         }
  712.         
  713.         ResponseCachingConfigurazione responseCachingConfigurazione = new ResponseCachingConfigurazione();
  714.         responseCachingConfigurazione.setStato(StatoFunzionalita.DISABILITATO);
  715.         String prefixConnettore = "[EndpointNegoziazioneToken: "+endpoint+"] ";
  716.         if(endpointConfig.containsKey(CostantiConnettori.CONNETTORE_HTTP_PROXY_HOSTNAME)) {
  717.             String hostProxy = endpointConfig.getProperty(CostantiConnettori.CONNETTORE_HTTP_PROXY_HOSTNAME);
  718.             String portProxy = endpointConfig.getProperty(CostantiConnettori.CONNETTORE_HTTP_PROXY_PORT);
  719.             prefixConnettore = prefixConnettore+GestoreToken.getMessageViaProxy(hostProxy, portProxy);
  720.         }
  721.         if(datiRichiesta!=null && datiRichiesta.getPrepareRequest()!=null) {
  722.             datiRichiesta.setSendRequest(DateManager.getDate());
  723.         }
  724.         boolean send = connettore.send(responseCachingConfigurazione, connettoreMsg);
  725.         if(datiRichiesta!=null && datiRichiesta.getPrepareRequest()!=null) {
  726.             datiRichiesta.setReceiveResponse(DateManager.getDate());
  727.         }
  728.         if(!send) {
  729.             if(connettore.getEccezioneProcessamento()!=null) {
  730.                 throw new TokenException(prefixConnettore+connettore.getErrore(), connettore.getEccezioneProcessamento());
  731.             }
  732.             else {
  733.                 throw new TokenException(prefixConnettore+connettore.getErrore());
  734.             }
  735.         }
  736.         
  737.         OpenSPCoop2Message msgResponse = connettore.getResponse();
  738.         ByteArrayOutputStream bout = null;
  739.         if(msgResponse!=null) {
  740.             try {
  741.                 bout = new ByteArrayOutputStream();
  742.                 if(msgResponse!=null) {
  743.                     msgResponse.writeTo(bout, true);
  744.                 }
  745.                 bout.flush();
  746.                 bout.close();
  747.             }catch(Exception e) {
  748.                 throw new TokenException(e.getMessage(),e);
  749.             }
  750.         }
  751.         
  752.         HttpResponse httpResponse = new HttpResponse();
  753.         httpResponse.setResultHTTPOperation(connettore.getCodiceTrasporto());
  754.         
  755.         if(connettore.getCodiceTrasporto() >= 200 &&  connettore.getCodiceTrasporto() < 299) {
  756.             String msgSuccess = prefixConnettore+GestoreToken.getMessageConnettoreConnessioneSuccesso(connettore);
  757.             if(bout!=null && bout.size()>0) {
  758.                 log.debug(msgSuccess);
  759.                 httpResponse.setContent(bout.toByteArray());
  760.                 return httpResponse;
  761.             }
  762.             else {
  763.                 throw new TokenException(msgSuccess+GestoreToken.CONNETTORE_RISPOSTA_NON_PERVENUTA);
  764.             }
  765.         }
  766.         else {
  767.             String msgError = prefixConnettore+GestoreToken.getMessageConnettoreConnessioneErrore(connettore);
  768.             if(bout!=null && bout.size()>0) {
  769.                 String e = msgError+": "+bout.toString();
  770.                 log.debug(e);
  771.                 httpResponse.setContent(bout.toByteArray());
  772.                 return httpResponse;
  773.             }
  774.             else {
  775.                 log.error(msgError);
  776.                 throw new TokenException(msgError);
  777.             }
  778.         }
  779.         
  780.         
  781.     }
  782.     
  783.     private static String getNomeSoggettoInterno(Busta busta, TipoPdD tipoPdD, 
  784.             IProtocolFactory<?> protocolFactory, RequestInfo requestInfo, 
  785.             OpenSPCoop2Properties op2Properties) {
  786.         // soggetto interno
  787.         String nomeSoggettoInterno = null;
  788.         if(TipoPdD.APPLICATIVA.equals(tipoPdD) && busta!=null && busta.getDestinatario()!=null) {
  789.             nomeSoggettoInterno = busta.getDestinatario();
  790.         }
  791.         else if(TipoPdD.DELEGATA.equals(tipoPdD) && busta!=null && busta.getMittente()!=null) {
  792.             nomeSoggettoInterno = busta.getMittente();
  793.         }
  794.         else {
  795.             nomeSoggettoInterno = op2Properties.getIdentitaPortaDefault(protocolFactory!=null ? protocolFactory.getProtocol() : null, requestInfo).getNome();
  796.         }
  797.         return nomeSoggettoInterno;
  798.     }
  799.     
  800.     private static boolean isTokenPolicyVersoPDND(PolicyNegoziazioneToken policyNegoziazioneToken, OpenSPCoop2Properties op2Properties, IProtocolFactory<?> protocolFactory) throws TokenException {
  801.         boolean pdnd = policyNegoziazioneToken.isPDND();
  802.         if(!pdnd) {
  803.             // per client interop verifico la url
  804.             try {
  805.                 pdnd = policyNegoziazioneToken.getEndpoint()!=null && RegularExpressionEngine.isMatch(policyNegoziazioneToken.getEndpoint(), 
  806.                         op2Properties.getGestioneRetrieveTokenPdndUrlPatternMatch(protocolFactory!=null ? protocolFactory.getProtocol() : null));
  807.             }catch(RegExpNotFoundException notFound) {
  808.                 pdnd = false;
  809.             }catch(Exception e) {
  810.                 throw new TokenException(e.getMessage(),e);
  811.             }
  812.         }
  813.         return pdnd;
  814.     }
  815.     
  816.     private static String buildJwt(PolicyNegoziazioneToken policyNegoziazioneToken,
  817.             Busta busta, TipoPdD tipoPdD,
  818.             NegoziazioneTokenDynamicParameters dynamicParameters, 
  819.             IProtocolFactory<?> protocolFactory, RequestInfo requestInfo) throws TokenException, UtilsException {
  820.         
  821.         // https://datatracker.ietf.org/doc/html/rfc7523
  822.         
  823.         OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  824.         JSONUtils jsonUtils = JSONUtils.getInstance(false);
  825.         
  826.         ObjectNode jwtPayload = jsonUtils.newObjectNode();

  828.         // indicazione se siamo in una token policy PDND
  829.         boolean pdnd = isTokenPolicyVersoPDND(policyNegoziazioneToken, op2Properties, protocolFactory);
  830.         
  831.         // soggetto interno
  832.         String nomeSoggettoInterno = getNomeSoggettoInterno(busta, tipoPdD, 
  833.                 protocolFactory, requestInfo, 
  834.                 op2Properties);
  835.         
  836.         // add iat, nbf, exp
  837.         long nowMs = DateManager.getTimeMillis();
  838.         long nowSeconds = nowMs/1000;
  839.         
  840.         String issuer = dynamicParameters.getSignedJwtIssuer();
  841.         if(issuer==null) {
  842.             issuer = nomeSoggettoInterno;
  843.         }
  844.         if(!Costanti.POLICY_RETRIEVE_TOKEN_JWT_CLAIM_UNDEFINED.equals(issuer)) {
  845.             jwtPayload.put(Claims.OIDC_ID_TOKEN_ISSUER, issuer);
  846.         }
  847.         
  848.         // For client authentication, the subject MUST be the "client_id" of the OAuth client.
  849.         String clientId = dynamicParameters.getSignedJwtClientId();
  850.         if(clientId==null) {
  851.             throw new TokenException("ClientID undefined");
  852.         }
  853.         if( 
  854.                 !Costanti.POLICY_RETRIEVE_TOKEN_JWT_CLAIM_UNDEFINED.equals(clientId) 
  855.                 && 
  856.                 (!pdnd || op2Properties.isGestioneRetrieveTokenPdndPayloadClientId(protocolFactory!=null ? protocolFactory.getProtocol() : null, nomeSoggettoInterno))
  857.             ) {
  858.             jwtPayload.put(Claims.INTROSPECTION_RESPONSE_RFC_7662_CLIENT_ID, clientId);
  859.         }
  860.         
  861.         String subject = dynamicParameters.getSignedJwtSubject();
  862.         if(StringUtils.isNotEmpty(subject)) {
  863.             if(!Costanti.POLICY_RETRIEVE_TOKEN_JWT_CLAIM_UNDEFINED.equals(subject)) {
  864.                 jwtPayload.put(Claims.OIDC_ID_TOKEN_SUBJECT, subject);
  865.             }
  866.         }
  867.         else {
  868.             if(!Costanti.POLICY_RETRIEVE_TOKEN_JWT_CLAIM_UNDEFINED.equals(clientId)) {
  869.                 jwtPayload.put(Claims.OIDC_ID_TOKEN_SUBJECT, clientId);
  870.             }
  871.         }
  872.         
  873.         // The JWT MUST contain an "aud" (audience) claim containing a value that identifies the authorization server as an intended audience. 
  874.         String jwtAudience = dynamicParameters.getSignedJwtAudience();
  875.         if(jwtAudience==null) {
  876.             throw new TokenException("JWT-Audience undefined");
  877.         }
  878.         if(!Costanti.POLICY_RETRIEVE_TOKEN_JWT_CLAIM_UNDEFINED.equals(jwtAudience)) {
  879.             jwtPayload.put(Claims.OIDC_ID_TOKEN_AUDIENCE, jwtAudience);
  880.         }
  881.         
  882.         // The JWT MAY contain an "iat" (issued at) claim that identifies the time at which the JWT was issued. 
  883.         jwtPayload.put(Claims.JSON_WEB_TOKEN_RFC_7519_ISSUED_AT, nowSeconds);
  884.         
  885.         // The JWT MAY contain an "nbf" (not before) claim that identifies the time before which the token MUST NOT be accepted for processing.
  886.         if(!pdnd || op2Properties.isGestioneRetrieveTokenPdndPayloadNbf(protocolFactory!=null ? protocolFactory.getProtocol() : null, nomeSoggettoInterno)) {
  887.             jwtPayload.put(Claims.JSON_WEB_TOKEN_RFC_7519_NOT_TO_BE_USED_BEFORE, nowSeconds);
  888.         }
  889.         
  890.         // The JWT MUST contain an "exp" (expiration time) claim that limits the time window during which the JWT can be used.
  891.         int ttl = -1;
  892.         try {
  893.             ttl = policyNegoziazioneToken.getJwtTtlSeconds();
  894.         }catch(Exception e) {
  895.             throw new TokenException("Invalid JWT-TimeToLive value: "+e.getMessage(),e);
  896.         }
  897.         long expired = nowSeconds+ttl;
  898.         jwtPayload.put(Claims.JSON_WEB_TOKEN_RFC_7519_EXPIRED, expired);
  899.         
  900.         // The JWT MAY contain a "jti" (JWT ID) claim that provides a unique identifier for the token.
  901.         String jti = dynamicParameters.getSignedJwtJti();
  902.         if(StringUtils.isNotEmpty(jti)) {
  903.             if(!Costanti.POLICY_RETRIEVE_TOKEN_JWT_CLAIM_UNDEFINED.equals(jti)) {
  904.                 jwtPayload.put(Claims.JSON_WEB_TOKEN_RFC_7519_JWT_ID, jti);
  905.             }
  906.         }
  907.         else {
  908.             // per default genero un uuid
  909.             String uuid = null;
  910.             try {
  911.                 uuid = UniqueIdentifierManager.newUniqueIdentifier().toString();
  912.             }catch(Exception e) {
  913.                 throw new TokenException("Invalid JWT-TimeToLive value: "+e.getMessage(),e);
  914.             }
  915.             jwtPayload.put(Claims.JSON_WEB_TOKEN_RFC_7519_JWT_ID, uuid);
  916.         }
  917.         
  918.         if(policyNegoziazioneToken.isPDND()) {
  919.             
  920.             // purposeId
  921.             String jwtPurposeId = dynamicParameters.getSignedJwtPurposeId();
  922.             if(jwtPurposeId==null) {
  923.                 throw new TokenException("JWT-PurposeId undefined");
  924.             }
  925.             if(!Costanti.POLICY_RETRIEVE_TOKEN_JWT_CLAIM_UNDEFINED.equals(jwtPurposeId)) {
  926.                 jwtPayload.put(Costanti.PDND_PURPOSE_ID, jwtPurposeId);
  927.             }
  928.             
  929.             // sessionInfo
  930.             String sessionInfo = dynamicParameters.getSignedJwtSessionInfo();
  931.             if(sessionInfo!=null && !"".equals(sessionInfo)) {
  932.                 Properties convertTextToProperties = PropertiesUtilities.convertTextToProperties(sessionInfo);
  933.                 ObjectNode sessionInfoPayload = null;
  934.                 if(convertTextToProperties!=null && !convertTextToProperties.isEmpty()) {
  935.                     Enumeration<Object> keys = convertTextToProperties.keys();
  936.                     while (keys.hasMoreElements()) {
  937.                         String nome = (String) keys.nextElement();
  938.                         if(nome!=null && !"".equals(nome)) {
  939.                             String valore = convertTextToProperties.getProperty(nome);
  940.                             if(valore!=null) {
  941.                                 if(sessionInfoPayload ==null) {
  942.                                     sessionInfoPayload = jsonUtils.newObjectNode();
  943.                                 }
  944.                                 jsonUtils.putValue(sessionInfoPayload, nome, valore);
  945.                             }
  946.                         }
  947.                     }
  948.                 }
  949.                 if(sessionInfoPayload!=null) {
  950.                     jwtPayload.set(Costanti.PDND_SESSION_INFO, sessionInfoPayload);
  951.                 }
  952.             }
  953.         }
  954.         
  955.         // digest Audit
  956.         String digestAudit = dynamicParameters.getSignedJwtAuditDigest();
  957.         if(digestAudit!=null && StringUtils.isNotEmpty(digestAudit)) {
  958.             String algorithm = dynamicParameters.getSignedJwtAuditDigestAlgo();
  959.             if(algorithm==null || StringUtils.isEmpty(algorithm)) {
  960.                 algorithm = Costanti.PDND_DIGEST_ALG_DEFAULT_VALUE;
  961.             }
  962.             
  963.             ObjectNode digest = jsonUtils.newObjectNode();
  964.             digest.put(Costanti.PDND_DIGEST_ALG, algorithm);
  965.             digest.put(Costanti.PDND_DIGEST_VALUE, digestAudit);
  966.             jwtPayload.set(Costanti.PDND_DIGEST, digest);
  967.         }
  968.         
  969.         // claims
  970.         String claims = dynamicParameters.getSignedJwtClaims();
  971.         if(claims!=null && !"".equals(claims)) {
  972.             Properties convertTextToProperties = PropertiesUtilities.convertTextToProperties(claims);
  973.             if(convertTextToProperties!=null && !convertTextToProperties.isEmpty()) {
  974.                 Enumeration<Object> keys = convertTextToProperties.keys();
  975.                 while (keys.hasMoreElements()) {
  976.                     String nome = (String) keys.nextElement();
  977.                     if(nome!=null && !"".equals(nome)) {
  978.                         String valore = convertTextToProperties.getProperty(nome);
  979.                         if(valore!=null) {
  980.                             jsonUtils.putValue(jwtPayload, nome, valore);
  981.                         }
  982.                     }
  983.                 }
  984.             }
  985.         }
  986.         
  987.         return jsonUtils.toString(jwtPayload);
  988.     }
  989.     
  990.     public static KeystoreParams readKeystoreParams(PolicyNegoziazioneToken policyNegoziazioneToken) throws TokenException {
  991.         
  992.         KeystoreParams kp = new KeystoreParams();
  993.         
  994.         String keystoreType = policyNegoziazioneToken.getJwtSignKeystoreType();
  995.         if(keystoreType==null) {
  996.             throw new TokenException(GestoreToken.KEYSTORE_TYPE_UNDEFINED);
  997.         }
  998.         kp.setType(keystoreType);
  999.         
  1000.         fillKeystoreParams(policyNegoziazioneToken, keystoreType, kp);
  1001.                 
  1002.         String keyAlias = policyNegoziazioneToken.getJwtSignKeyAlias();
  1003.         if(keyAlias==null && 
  1004.                 !SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType) && 
  1005.                 !SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(keystoreType)) {
  1006.             throw new TokenException(GestoreToken.KEY_ALIAS_UNDEFINED);
  1007.         }
  1008.         kp.setKeyAlias(keyAlias);
  1009.         
  1010.         String keyPassword = policyNegoziazioneToken.getJwtSignKeyPassword();
  1011.         if(keyPassword==null && 
  1012.                 !SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(keystoreType) && 
  1013.                 !SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType) && 
  1014.                 !SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(keystoreType)) {
  1015.             boolean required = true;
  1016.             if(KeystoreType.JKS.isType(keystoreType)) {
  1017.                 required = DBUtils.isKeystoreJksKeyPasswordRequired();
  1018.             }
  1019.             else if(KeystoreType.PKCS12.isType(keystoreType)) {
  1020.                 required = DBUtils.isKeystorePkcs12KeyPasswordRequired();
  1021.             }
  1022.             if(required) {
  1023.                 throw new TokenException(GestoreToken.KEY_PASSWORD_UNDEFINED);
  1024.             }
  1025.         }
  1026.         kp.setKeyPassword(keyPassword);
  1027.         
  1028.         return kp;
  1029.     }
  1030.     private static void fillKeystoreParams(PolicyNegoziazioneToken policyNegoziazioneToken, String keystoreType, KeystoreParams kp) throws TokenException {
  1031.         String keystoreFile = null;
  1032.         String keystoreFilePublicKey = null;
  1033.         String keyPairAlgorithm = null;
  1034.         if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType)) {
  1035.             keystoreFile = policyNegoziazioneToken.getJwtSignKeystoreFile();
  1036.             if(keystoreFile==null) {
  1037.                 throw new TokenException(GestoreToken.KEYSTORE_PRIVATE_KEY_UNDEFINED);
  1038.             }
  1039.             kp.setPath(keystoreFile);
  1040.             
  1041.             keystoreFilePublicKey = policyNegoziazioneToken.getJwtSignKeystoreFilePublicKey();
  1042.             if(keystoreFilePublicKey==null) {
  1043.                 throw new TokenException(GestoreToken.KEYSTORE_PUBLIC_KEY_UNDEFINED);
  1044.             }
  1045.             kp.setKeyPairPublicKeyPath(keystoreFilePublicKey);
  1046.             
  1047.             keyPairAlgorithm = policyNegoziazioneToken.getJwtSignKeyPairAlgorithm();
  1048.             if(keyPairAlgorithm==null) {
  1049.                 throw new TokenException(GestoreToken.KEYSTORE_KEY_PAIR_ALGORITHM_UNDEFINED);
  1050.             }
  1051.             kp.setKeyPairAlgorithm(keyPairAlgorithm);
  1052.         }
  1053.         else {
  1054.             keystoreFile = policyNegoziazioneToken.getJwtSignKeystoreFile();
  1055.             if(keystoreFile==null) {
  1056.                 throw new TokenException(GestoreToken.KEYSTORE_KEYSTORE_FILE_UNDEFINED);
  1057.             }
  1058.             kp.setPath(keystoreFile);
  1059.         }
  1060.         
  1061.         String keystorePassword = policyNegoziazioneToken.getJwtSignKeystorePassword();
  1062.         if(keystorePassword==null && 
  1063.                 !SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(keystoreType) && 
  1064.                 !SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType) && 
  1065.                 !SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(keystoreType)) {
  1066.             boolean required = true;
  1067.             if(KeystoreType.JKS.isType(keystoreType)) {
  1068.                 required = DBUtils.isKeystoreJksPasswordRequired();
  1069.             }
  1070.             else if(KeystoreType.PKCS12.isType(keystoreType)) {
  1071.                 required = DBUtils.isKeystorePkcs12PasswordRequired();
  1072.             }
  1073.             if(required) {
  1074.                 throw new TokenException(GestoreToken.KEYSTORE_KEYSTORE_PASSWORD_UNDEFINED);
  1075.             }
  1076.         }
  1077.         kp.setPassword(keystorePassword);
  1078.         
  1079.         String keystoreByokPolicy = policyNegoziazioneToken.getJwtSignKeystoreByokPolicy();
  1080.         kp.setByokPolicy(keystoreByokPolicy);
  1081.     }
  1082.     
  1083.     private static String signJwt(PolicyNegoziazioneToken policyNegoziazioneToken, String payload, String contentType,
  1084.             NegoziazioneTokenDynamicParameters dynamicParameters,
  1085.             Busta busta, RequestInfo requestInfo, Logger log) throws TokenException, SecurityException, UtilsException {
  1086.         
  1087.         String signAlgo = policyNegoziazioneToken.getJwtSignAlgorithm();
  1088.         if(signAlgo==null) {
  1089.             throw new TokenException("SignAlgorithm undefined");
  1090.         }
  1091.         
  1092.         KeyStore ks = null;
  1093.         KeyPairStore keyPairStore = null;
  1094.         JWKSetStore jwtStore = null;
  1095.         String keyAlias = null;
  1096.         String keyPassword = null;
  1097.         if(policyNegoziazioneToken.isRfc7523x509Grant()) {
  1098.             
  1099.             if(policyNegoziazioneToken.isJwtSignKeystoreApplicativoModI()) {
  1100.                 
  1101.                 Map<String, Object> dynamicMap = null;
  1102.                 if(dynamicParameters.isByokPolicyDefinedApplicativoModI()) {
  1103.                     dynamicMap = DynamicMapBuilderUtils.buildDynamicMap(busta, 
  1104.                             requestInfo, dynamicParameters.getPddContext(), log);
  1105.                 }
  1106.                 
  1107.                 String keystoreType = dynamicParameters.getTipoKeystoreApplicativoModI();
  1108.                 if(keystoreType==null) {
  1109.                     throw new TokenException(GestoreToken.KEYSTORE_TYPE_UNDEFINED);
  1110.                 }
  1111.                 if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType)) {
  1112.                     keyPairStore = dynamicParameters.getKeyPairStoreApplicativoModI(dynamicMap);
  1113.                     if(keyPairStore==null) {
  1114.                         throw new TokenException(GestoreToken.KEYSTORE_KEYPAIR_UNDEFINED);
  1115.                     }
  1116.                 }
  1117.                 else if(SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(keystoreType)) {
  1118.                     jwtStore =  dynamicParameters.getJWKSetStoreApplicativoModI(dynamicMap);
  1119.                     if(jwtStore==null) {
  1120.                         throw new TokenException(GestoreToken.KEYSTORE_KEYSTORE_UNDEFINED);
  1121.                     }
  1122.                 }
  1123.                 else {
  1124.                     ks = dynamicParameters.getKeystoreApplicativoModI(dynamicMap);
  1125.                     if(ks==null) {
  1126.                         throw new TokenException(GestoreToken.KEYSTORE_KEYSTORE_UNDEFINED);
  1127.                     }
  1128.                 }
  1129.                 
  1130.                 keyAlias = dynamicParameters.getKeyAliasApplicativoModI();
  1131.                 if(keyAlias==null && 
  1132.                         !SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType) && 
  1133.                         !SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(keystoreType)) {
  1134.                     throw new TokenException(GestoreToken.KEY_ALIAS_UNDEFINED);
  1135.                 }
  1136.                 keyPassword = dynamicParameters.getKeyPasswordApplicativoModI();
  1137.                 if(keyPassword==null && 
  1138.                         !SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(keystoreType) && 
  1139.                         !SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType) && 
  1140.                         !SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(keystoreType)) {
  1141.                     throw new TokenException(GestoreToken.KEY_PASSWORD_UNDEFINED);
  1142.                 }
  1143.             }
  1144.             else if(policyNegoziazioneToken.isJwtSignKeystoreFruizioneModI()) {
  1145.                 
  1146.                 Map<String, Object> dynamicMap = null;
  1147.                 if(dynamicParameters.isByokPolicyDefinedFruizioneModI()) {
  1148.                     dynamicMap = DynamicMapBuilderUtils.buildDynamicMap(busta, 
  1149.                             requestInfo, dynamicParameters.getPddContext(), log);
  1150.                 }
  1151.                 
  1152.                 String keystoreType = dynamicParameters.getTipoKeystoreFruizioneModI();
  1153.                 if(keystoreType==null) {
  1154.                     throw new TokenException(GestoreToken.KEYSTORE_TYPE_UNDEFINED);
  1155.                 }
  1156.                 if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType)) {
  1157.                     keyPairStore = dynamicParameters.getKeyPairStoreFruizioneModI(dynamicMap);
  1158.                     if(keyPairStore==null) {
  1159.                         throw new TokenException(GestoreToken.KEYSTORE_KEYPAIR_UNDEFINED);
  1160.                     }
  1161.                 }
  1162.                 else if(SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(keystoreType)) {
  1163.                     jwtStore =  dynamicParameters.getJWKSetStoreFruizioneModI(dynamicMap);
  1164.                     if(jwtStore==null) {
  1165.                         throw new TokenException(GestoreToken.KEYSTORE_KEYSTORE_UNDEFINED);
  1166.                     }
  1167.                 }
  1168.                 else {
  1169.                     ks = dynamicParameters.getKeystoreFruizioneModI(dynamicMap);
  1170.                     if(ks==null) {
  1171.                         throw new TokenException(GestoreToken.KEYSTORE_KEYSTORE_UNDEFINED);
  1172.                     }
  1173.                 }
  1174.                 
  1175.                 keyAlias = dynamicParameters.getKeyAliasFruizioneModI();
  1176.                 if(keyAlias==null && 
  1177.                         !SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType) && 
  1178.                         !SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(keystoreType)) {
  1179.                     throw new TokenException(GestoreToken.KEY_ALIAS_UNDEFINED);
  1180.                 }
  1181.                 keyPassword = dynamicParameters.getKeyPasswordFruizioneModI();
  1182.                 if(keyPassword==null && 
  1183.                         !SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(keystoreType) && 
  1184.                         !SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType) && 
  1185.                         !SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(keystoreType)) {
  1186.                     throw new TokenException(GestoreToken.KEY_PASSWORD_UNDEFINED);
  1187.                 }
  1188.             }
  1189.             else {
  1190.                 KeystoreParams kp = readKeystoreParams(policyNegoziazioneToken);

  1192.                 String keystoreType = kp.getType(); 
  1193.                 String keystoreFile = kp.getPath();
  1194.                 String keystoreFilePublicKey = kp.getKeyPairPublicKeyPath();
  1195.                 String keyPairAlgorithm = kp.getKeyPairAlgorithm();
  1196.                 String keystorePassword = kp.getPassword();
  1197.                 
  1198.                 keyAlias = kp.getKeyAlias();                
  1199.                 keyPassword = kp.getKeyPassword();
  1200.                 
  1201.                 String keystoreByokPolicy = kp.getByokPolicy();
  1202.                 BYOKRequestParams byokParams = null;
  1203.                 if(BYOKProvider.isPolicyDefined(keystoreByokPolicy)) {
  1204.                     Map<String, Object> dynamicMap = DynamicMapBuilderUtils.buildDynamicMap(busta, 
  1205.                             requestInfo, dynamicParameters.getPddContext(), log);
  1206.                     byokParams = BYOKProvider.getBYOKRequestParamsByUnwrapBYOKPolicy(keystoreByokPolicy, 
  1207.                             dynamicMap );
  1208.                 }
  1209.                 
  1210.                 if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType)) {
  1211.                     keyPairStore = GestoreKeystoreCache.getKeyPairStore(requestInfo, keystoreFile, keystoreFilePublicKey, keyPassword, keyPairAlgorithm, byokParams);
  1212.                 }
  1213.                 else if(SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(keystoreType)) {
  1214.                     jwtStore = GestoreKeystoreCache.getJwkSetStore(requestInfo, keystoreFile, byokParams);
  1215.                 }
  1216.                 else {
  1217.                     MerlinKeystore merlinKs = GestoreKeystoreCache.getMerlinKeystore(requestInfo, keystoreFile, keystoreType, keystorePassword, byokParams);
  1218.                     if(merlinKs==null) {
  1219.                         throw new TokenException("Accesso al keystore '"+keystoreFile+"' non riuscito");
  1220.                     }
  1221.                     ks = merlinKs.getKeyStore();
  1222.                 }
  1223.             }
  1224.         }
  1225.         
  1226.         JWSOptions options = new JWSOptions(JOSESerialization.COMPACT);
  1227.         
  1228.         JwtHeaders jwtHeaders = new JwtHeaders();
  1229.         if(policyNegoziazioneToken.isJwtSignIncludeKeyIdWithKeyAlias()) {
  1230.             jwtHeaders.setKid(keyAlias);
  1231.         }
  1232.         else if(policyNegoziazioneToken.isJwtSignIncludeKeyIdWithClientId()) {
  1233.             String clientId = dynamicParameters.getSignedJwtClientId();
  1234.             jwtHeaders.setKid(clientId);
  1235.         }
  1236.         else if(policyNegoziazioneToken.isJwtSignIncludeKeyIdCustom()) {
  1237.             String customId = dynamicParameters.getSignedJwtCustomId();
  1238.             jwtHeaders.setKid(customId);
  1239.         }
  1240.         else if(policyNegoziazioneToken.isJwtSignIncludeKeyIdApplicativoModI()) {
  1241.             String clientId = dynamicParameters.getKidApplicativoModI();
  1242.             jwtHeaders.setKid(clientId);
  1243.         }
  1244.         else if(policyNegoziazioneToken.isJwtSignIncludeKeyIdFruizioneModI()) {
  1245.             String clientId = dynamicParameters.getKidFruizioneModI();
  1246.             jwtHeaders.setKid(clientId);
  1247.         }
  1248.         if(policyNegoziazioneToken.isJwtSignIncludeX509Cert()) {
  1249.             jwtHeaders.setAddX5C(true);
  1250.         }
  1251.         String url = dynamicParameters.getSignedJwtX509Url();
  1252.         if(url!=null && !"".equals(url)) {
  1253.             try {
  1254.                 jwtHeaders.setX509Url(new URI(url));
  1255.             }catch(Exception e) {
  1256.                 throw new TokenException(e.getMessage(),e);
  1257.             }
  1258.         }
  1259.         if(policyNegoziazioneToken.isJwtSignIncludeX509CertSha1()) {
  1260.             jwtHeaders.setX509IncludeCertSha1(true);
  1261.         }
  1262.         if(policyNegoziazioneToken.isJwtSignIncludeX509CertSha256()) {
  1263.             jwtHeaders.setX509IncludeCertSha256(true);
  1264.         }
  1265.         if(policyNegoziazioneToken.isJwtSignJoseContentType() &&
  1266.             contentType!=null && !"".equals(contentType)) {
  1267.             jwtHeaders.setContentType(contentType);
  1268.         }
  1269.         String type = policyNegoziazioneToken.getJwtSignJoseType();
  1270.         if(type!=null && !"".equals(type) && !Costanti.POLICY_RETRIEVE_TOKEN_JWT_CLAIM_UNDEFINED.equals(type)) { // funzionalita' undefined undocumented
  1271.             jwtHeaders.setType(type);
  1272.         }
  1273.         if(ks!=null) {
  1274.             Certificate cert = ks.getCertificate(keyAlias);
  1275.             if(cert instanceof X509Certificate) {
  1276.                 jwtHeaders.addX509cert((X509Certificate)cert);
  1277.             }
  1278.         }
  1279.         
  1280.         if(policyNegoziazioneToken.isRfc7523ClientSecretGrant()) {
  1281.         
  1282.             String clientSecret = policyNegoziazioneToken.getJwtClientSecret();
  1283.             if(clientSecret==null) {
  1284.                 throw new TokenException("ClientSecret undefined");
  1285.             }
  1286.             
  1287.             JsonSignature jsonSignature = new JsonSignature(clientSecret, signAlgo, jwtHeaders, options);
  1288.             return jsonSignature.sign(payload);
  1289.         }
  1290.         else if(policyNegoziazioneToken.isRfc7523x509Grant()) {
  1291.                         
  1292.             JsonSignature jsonSignature = null;
  1293.             if(keyPairStore!=null || jwtStore!=null) {
  1294.                 JsonWebKeys jwk = null;
  1295.                 if(keyPairStore!=null) {
  1296.                     jwk = keyPairStore.getJwkSet().getJsonWebKeys();
  1297.                     keyAlias = keyPairStore.getJwkSetKid();
  1298.                 }
  1299.                 else {
  1300.                     jwk = jwtStore.getJwkSet().getJsonWebKeys();
  1301.                 }
  1302.                 jsonSignature = new JsonSignature(jwk, false, keyAlias, signAlgo, jwtHeaders, options);
  1303.             }
  1304.             else {
  1305.                 jsonSignature = new JsonSignature(ks, false, keyAlias,  keyPassword, signAlgo, jwtHeaders, options);
  1306.             }
  1307.             return jsonSignature.sign(payload);
  1308.         }
  1309.         else {
  1310.             throw new TokenException("JWT Signed mode unknown");
  1311.         }
  1312.         
  1313.     }
  1314.     
  1315.     
  1316.     
  1317.     
  1318.     // ********* [NEGOZIAZIONE-TOKEN] UTILITIES INTERNE ****************** */
  1319.     
  1320.     public static Date updateNowForExpire(String debugMetodoChiamante, Date nowParam, Date iat, Date exp, Integer refreshTokenBeforeExpirePercent, Integer refreshTokenBeforeExpireSeconds) {
  1321.         Date now = nowParam;
  1322.         int secondsPreExpire = -1;
  1323.         if(iat!=null && refreshTokenBeforeExpirePercent!=null && refreshTokenBeforeExpirePercent>0) {
  1324.             int percent = refreshTokenBeforeExpirePercent;
  1325.             long secondsExpire = exp.getTime() / 1000l;
  1326.             long secondsIat = iat.getTime() / 1000l;
  1327.             long secondsDiff = secondsExpire - secondsIat;
  1328.             if(secondsDiff>0) {
  1329.                 float perc1 = Float.parseFloat(secondsDiff+"") / 100f;
  1330.                 float perc2 = perc1 * Float.parseFloat(percent+"");
  1331.                 int s = Math.round(perc2);
  1332.                 if(s>0) {
  1333.                     secondsPreExpire = s;
  1334.                 }
  1335.             }
  1336.         }
  1337.         else if(refreshTokenBeforeExpireSeconds!=null && refreshTokenBeforeExpireSeconds>0) {
  1338.             secondsPreExpire = refreshTokenBeforeExpireSeconds;
  1339.         }
  1340.         if(secondsPreExpire>0) {
  1341.             now = new Date(now.getTime() + (secondsPreExpire*1000));
  1342.             if(debugMetodoChiamante!=null) {
  1343.                 /**System.out.println("Controllo scadenza per rinegoziazione '"+debugMetodoChiamante+"' now+tollerance("+secondsPreExpire+")["+org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(now)+"] exp["+
  1344.                     org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(exp)+"] isExpired["+!now.before(exp)+"]");*/
  1345.             }
  1346.         }
  1347.         return now;
  1348.     }
  1349. }
Created with JaCoCo 0.8.8.202204050719