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.  */

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

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

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

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

  99. /**    
  100.  * GestoreTokenNegoziazioneUtilities
  101.  *
  102.  * @author Poli Andrea (poli@link.it)
  103.  * @author $Author$
  104.  * @version $Rev$, $Date$
  105.  */
  106. public class GestoreTokenNegoziazioneUtilities {
  107.    
  108.     private GestoreTokenNegoziazioneUtilities() {}

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

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

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

  1221.                 String keystoreType = kp.getType();
  1222.                 String keystoreFile = kp.getPath();
  1223.                 String keystoreFilePublicKey = kp.getKeyPairPublicKeyPath();
  1224.                 String keyPairAlgorithm = kp.getKeyPairAlgorithm();
  1225.                 String keystorePassword = kp.getPassword();
  1226.                
  1227.                 keyAlias = kp.getKeyAlias();                
  1228.                 keyPassword = kp.getKeyPassword();
  1229.                
  1230.                 String keystoreByokPolicy = kp.getByokPolicy();
  1231.                 BYOKRequestParams byokParams = null;
  1232.                 if(BYOKProvider.isPolicyDefined(keystoreByokPolicy)) {
  1233.                     Map<String, Object> dynamicMap = DynamicMapBuilderUtils.buildDynamicMap(busta,
  1234.                             requestInfo, dynamicParameters.getPddContext(), log);
  1235.                     byokParams = BYOKProvider.getBYOKRequestParamsByUnwrapBYOKPolicy(keystoreByokPolicy,
  1236.                             dynamicMap );
  1237.                 }
  1238.                
  1239.                 if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType)) {
  1240.                     keyPairStore = GestoreKeystoreCache.getKeyPairStore(requestInfo, keystoreFile, keystoreFilePublicKey, keyPassword, keyPairAlgorithm, byokParams);
  1241.                 }
  1242.                 else if(SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(keystoreType)) {
  1243.                     jwtStore = GestoreKeystoreCache.getJwkSetStore(requestInfo, keystoreFile, byokParams);
  1244.                 }
  1245.                 else {
  1246.                     MerlinKeystore merlinKs = GestoreKeystoreCache.getMerlinKeystore(requestInfo, keystoreFile, keystoreType, keystorePassword, byokParams);
  1247.                     if(merlinKs==null) {
  1248.                         throw new TokenException("Accesso al keystore '"+keystoreFile+"' non riuscito");
  1249.                     }
  1250.                     ks = merlinKs.getKeyStore();
  1251.                 }
  1252.             }
  1253.         }
  1254.        
  1255.         JWSOptions options = new JWSOptions(JOSESerialization.COMPACT);
  1256.        
  1257.         JwtHeaders jwtHeaders = new JwtHeaders();
  1258.         if(policyNegoziazioneToken.isJwtSignIncludeKeyIdWithKeyAlias()) {
  1259.             jwtHeaders.setKid(keyAlias);
  1260.         }
  1261.         else if(policyNegoziazioneToken.isJwtSignIncludeKeyIdWithClientId()) {
  1262.             String clientId = dynamicParameters.getSignedJwtClientId();
  1263.             jwtHeaders.setKid(clientId);
  1264.         }
  1265.         else if(policyNegoziazioneToken.isJwtSignIncludeKeyIdCustom()) {
  1266.             String customId = dynamicParameters.getSignedJwtCustomId();
  1267.             jwtHeaders.setKid(customId);
  1268.         }
  1269.         else if(policyNegoziazioneToken.isJwtSignIncludeKeyIdApplicativoModI()) {
  1270.             String clientId = dynamicParameters.getKidApplicativoModI();
  1271.             jwtHeaders.setKid(clientId);
  1272.         }
  1273.         else if(policyNegoziazioneToken.isJwtSignIncludeKeyIdFruizioneModI()) {
  1274.             String clientId = dynamicParameters.getKidFruizioneModI();
  1275.             jwtHeaders.setKid(clientId);
  1276.         }
  1277.         if(policyNegoziazioneToken.isJwtSignIncludeX509Cert()) {
  1278.             jwtHeaders.setAddX5C(true);
  1279.         }
  1280.         String url = dynamicParameters.getSignedJwtX509Url();
  1281.         if(url!=null && !"".equals(url)) {
  1282.             try {
  1283.                 jwtHeaders.setX509Url(new URI(url));
  1284.             }catch(Exception e) {
  1285.                 throw new TokenException(e.getMessage(),e);
  1286.             }
  1287.         }
  1288.         if(policyNegoziazioneToken.isJwtSignIncludeX509CertSha1()) {
  1289.             jwtHeaders.setX509IncludeCertSha1(true);
  1290.         }
  1291.         if(policyNegoziazioneToken.isJwtSignIncludeX509CertSha256()) {
  1292.             jwtHeaders.setX509IncludeCertSha256(true);
  1293.         }
  1294.         if(policyNegoziazioneToken.isJwtSignJoseContentType() &&
  1295.             contentType!=null && !"".equals(contentType)) {
  1296.             jwtHeaders.setContentType(contentType);
  1297.         }
  1298.         String type = policyNegoziazioneToken.getJwtSignJoseType();
  1299.         if(type!=null && !"".equals(type) && !Costanti.POLICY_RETRIEVE_TOKEN_JWT_CLAIM_UNDEFINED.equals(type)) { // funzionalita' undefined undocumented
  1300.             jwtHeaders.setType(type);
  1301.         }
  1302.         if(ks!=null) {
  1303.             Certificate cert = ks.getCertificate(keyAlias);
  1304.             if(cert instanceof X509Certificate) {
  1305.                 jwtHeaders.addX509cert((X509Certificate)cert);
  1306.             }
  1307.         }
  1308.        
  1309.         if(policyNegoziazioneToken.isRfc7523ClientSecretGrant()) {
  1310.        
  1311.             String clientSecret = policyNegoziazioneToken.getJwtClientSecret();
  1312.             if(clientSecret==null) {
  1313.                 throw new TokenException("ClientSecret undefined");
  1314.             }
  1315.            
  1316.             JsonSignature jsonSignature = new JsonSignature(clientSecret, signAlgo, jwtHeaders, options);
  1317.             return jsonSignature.sign(payload);
  1318.         }
  1319.         else if(policyNegoziazioneToken.isRfc7523x509Grant()) {
  1320.                        
  1321.             JsonSignature jsonSignature = null;
  1322.             if(keyPairStore!=null || jwtStore!=null) {
  1323.                 JsonWebKeys jwk = null;
  1324.                 if(keyPairStore!=null) {
  1325.                     jwk = keyPairStore.getJwkSet().getJsonWebKeys();
  1326.                     keyAlias = keyPairStore.getJwkSetKid();
  1327.                 }
  1328.                 else {
  1329.                     jwk = jwtStore.getJwkSet().getJsonWebKeys();
  1330.                 }
  1331.                 jsonSignature = new JsonSignature(jwk, false, keyAlias, signAlgo, jwtHeaders, options);
  1332.             }
  1333.             else {
  1334.                 jsonSignature = new JsonSignature(ks, false, keyAlias,  keyPassword, signAlgo, jwtHeaders, options);
  1335.             }
  1336.             return jsonSignature.sign(payload);
  1337.         }
  1338.         else {
  1339.             throw new TokenException("JWT Signed mode unknown");
  1340.         }
  1341.        
  1342.     }
  1343. }