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


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

  24. import java.util.ArrayList;
  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;

  32. import javax.servlet.http.HttpServletRequest;

  34. import org.openspcoop2.core.commons.CoreException;
  35. import org.openspcoop2.core.config.AttributeAuthority;
  36. import org.openspcoop2.core.config.PortaApplicativa;
  37. import org.openspcoop2.core.config.PortaDelegata;
  38. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  39. import org.openspcoop2.core.constants.TipoPdD;
  40. import org.openspcoop2.core.id.IDGenericProperties;
  41. import org.openspcoop2.core.id.IDServizio;
  42. import org.openspcoop2.core.id.IDSoggetto;
  43. import org.openspcoop2.core.mvc.properties.provider.ProviderException;
  44. import org.openspcoop2.core.mvc.properties.provider.ProviderValidationException;
  45. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  46. import org.openspcoop2.message.OpenSPCoop2Message;
  47. import org.openspcoop2.message.utils.WWWAuthenticateErrorCode;
  48. import org.openspcoop2.message.utils.WWWAuthenticateGenerator;
  49. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  50. import org.openspcoop2.pdd.config.ConfigurazionePdDReader;
  51. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  52. import org.openspcoop2.pdd.core.PdDContext;
  53. import org.openspcoop2.pdd.core.connettori.ConnettoreBaseHTTP;
  54. import org.openspcoop2.pdd.core.connettori.ConnettoreMsg;
  55. import org.openspcoop2.pdd.core.dynamic.DynamicMapBuilderUtils;
  56. import org.openspcoop2.pdd.core.token.attribute_authority.AttributeAuthorityDynamicParameters;
  57. import org.openspcoop2.pdd.core.token.attribute_authority.AttributeAuthorityProvider;
  58. import org.openspcoop2.pdd.core.token.attribute_authority.EsitoRecuperoAttributi;
  59. import org.openspcoop2.pdd.core.token.attribute_authority.InformazioniAttributi;
  60. import org.openspcoop2.pdd.core.token.attribute_authority.PolicyAttributeAuthority;
  61. import org.openspcoop2.pdd.core.token.attribute_authority.pa.DatiInvocazionePortaApplicativa;
  62. import org.openspcoop2.pdd.core.token.attribute_authority.pd.DatiInvocazionePortaDelegata;
  63. import org.openspcoop2.pdd.core.token.pa.EsitoPresenzaTokenPortaApplicativa;
  64. import org.openspcoop2.pdd.core.token.pd.EsitoPresenzaTokenPortaDelegata;
  65. import org.openspcoop2.pdd.core.transazioni.Transaction;
  66. import org.openspcoop2.pdd.core.transazioni.TransactionContext;
  67. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  68. import org.openspcoop2.pdd.services.connector.FormUrlEncodedHttpServletRequest;
  69. import org.openspcoop2.protocol.engine.SecurityTokenUtilities;
  70. import org.openspcoop2.protocol.sdk.Busta;
  71. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  72. import org.openspcoop2.protocol.sdk.SecurityToken;
  73. import org.openspcoop2.protocol.sdk.state.IState;
  74. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  75. import org.openspcoop2.protocol.sdk.state.URLProtocolContext;
  76. import org.openspcoop2.security.message.jose.JOSEUtils;
  77. import org.openspcoop2.utils.SemaphoreLock;
  78. import org.openspcoop2.utils.UtilsException;
  79. import org.openspcoop2.utils.cache.Cache;
  80. import org.openspcoop2.utils.cache.CacheAlgorithm;
  81. import org.openspcoop2.utils.cache.CacheType;
  82. import org.openspcoop2.utils.cache.Constants;
  83. import org.openspcoop2.utils.date.DateManager;
  84. import org.openspcoop2.utils.date.DateUtils;
  85. import org.openspcoop2.utils.transport.TransportUtils;
  86. import org.openspcoop2.utils.transport.http.HttpConstants;
  87. import org.slf4j.Logger;

  89. /**     
  90.  * GestoreToken
  91.  *
  92.  * @author Poli Andrea (poli@link.it)
  93.  * @author $Author$
  94.  * @version $Rev$, $Date$
  95.  */
  96. public class GestoreToken {
  97.     
  98.     private GestoreToken() {}

  100.     public static final boolean PORTA_DELEGATA = true;
  101.     public static final boolean PORTA_APPLICATIVA = false;
  102.     
  103.     /** Chiave della cache per la gestione dei token  */
  104.     private static final String GESTIONE_TOKEN_CACHE_NAME = "token";
  105.     /** Chiave della cache per la gestione dei dati raccolti via attribute authority  */
  106.     private static final String ATTRIBUTE_AUTHORITY_CACHE_NAME = "attributeAuthority";
  107.     /** Cache */
  108.     private static Cache cacheGestioneToken = null;
  109.     private static Cache cacheAttributeAuthority = null;
  110.     
  111.     private static final Map<String, org.openspcoop2.utils.Semaphore> _lockDynamicDiscovery = new HashMap<>();
  112.     private static synchronized org.openspcoop2.utils.Semaphore initLockDynamicDiscovery(String nomePolicy){
  113.         org.openspcoop2.utils.Semaphore s = _lockDynamicDiscovery.get(nomePolicy);
  114.         if(s==null) {
  115.             Integer permits = OpenSPCoop2Properties.getInstance().getGestioneTokenDynamicDiscoveryLockPermits();
  116.             if(permits!=null && permits.intValue()>1) {
  117.                 s = new org.openspcoop2.utils.Semaphore("GestoreTokenDynamicDiscovery_"+nomePolicy, permits);
  118.             }
  119.             else {
  120.                 s = new org.openspcoop2.utils.Semaphore("GestoreTokenDynamicDiscovery_"+nomePolicy);
  121.             }
  122.             _lockDynamicDiscovery.put(nomePolicy, s);
  123.         }
  124.         return s;
  125.     }
  126.     private static org.openspcoop2.utils.Semaphore getLockDynamicDiscovery(String nomePolicy){
  127.         org.openspcoop2.utils.Semaphore s = _lockDynamicDiscovery.get(nomePolicy);
  128.         if(s==null) {
  129.             s = initLockDynamicDiscovery(nomePolicy);
  130.         }
  131.         return s;
  132.     } 
  133.     
  134.     private static final Map<String, org.openspcoop2.utils.Semaphore> _lockJWT = new HashMap<>();
  135.     private static synchronized org.openspcoop2.utils.Semaphore initLockJWT(String nomePolicy){
  136.         org.openspcoop2.utils.Semaphore s = _lockJWT.get(nomePolicy);
  137.         if(s==null) {
  138.             Integer permits = OpenSPCoop2Properties.getInstance().getGestioneTokenValidazioneJWTLockPermits();
  139.             if(permits!=null && permits.intValue()>1) {
  140.                 s = new org.openspcoop2.utils.Semaphore("GestoreTokenValidazioneJWT_"+nomePolicy, permits);
  141.             }
  142.             else {
  143.                 s = new org.openspcoop2.utils.Semaphore("GestoreTokenValidazioneJWT_"+nomePolicy);
  144.             }
  145.             _lockJWT.put(nomePolicy, s);
  146.         }
  147.         return s;
  148.     }
  149.     private static org.openspcoop2.utils.Semaphore getLockJWT(String nomePolicy){
  150.         org.openspcoop2.utils.Semaphore s = _lockJWT.get(nomePolicy);
  151.         if(s==null) {
  152.             s = initLockJWT(nomePolicy);
  153.         }
  154.         return s;
  155.     }
  156.     
  157.     private static final Map<String, org.openspcoop2.utils.Semaphore> _lockIntrospection = new HashMap<>();
  158.     private static synchronized org.openspcoop2.utils.Semaphore initLockIntrospection(String nomePolicy){
  159.         org.openspcoop2.utils.Semaphore s = _lockIntrospection.get(nomePolicy);
  160.         if(s==null) {
  161.             Integer permits = OpenSPCoop2Properties.getInstance().getGestioneTokenIntrospectionLockPermits();
  162.             if(permits!=null && permits.intValue()>1) {
  163.                 s = new org.openspcoop2.utils.Semaphore("GestoreTokenIntrospection_"+nomePolicy, permits);
  164.             }
  165.             else {
  166.                 s = new org.openspcoop2.utils.Semaphore("GestoreTokenIntrospection_"+nomePolicy);
  167.             }
  168.             _lockIntrospection.put(nomePolicy, s);
  169.         }
  170.         return s;
  171.     }
  172.     private static org.openspcoop2.utils.Semaphore getLockIntrospection(String nomePolicy){
  173.         org.openspcoop2.utils.Semaphore s = _lockIntrospection.get(nomePolicy);
  174.         if(s==null) {
  175.             s = initLockIntrospection(nomePolicy);
  176.         }
  177.         return s;
  178.     } 
  179.     
  180.     private static final Map<String, org.openspcoop2.utils.Semaphore> _lockUserInfo = new HashMap<>();
  181.     private static synchronized org.openspcoop2.utils.Semaphore initLockUserInfo(String nomePolicy){
  182.         org.openspcoop2.utils.Semaphore s = _lockUserInfo.get(nomePolicy);
  183.         if(s==null) {
  184.             Integer permits = OpenSPCoop2Properties.getInstance().getGestioneTokenUserInfoLockPermits();
  185.             if(permits!=null && permits.intValue()>1) {
  186.                 s = new org.openspcoop2.utils.Semaphore("GestoreTokenUserInfo_"+nomePolicy, permits);
  187.             }
  188.             else {
  189.                 s = new org.openspcoop2.utils.Semaphore("GestoreTokenUserInfo_"+nomePolicy);
  190.             }
  191.             _lockUserInfo.put(nomePolicy, s);
  192.         }
  193.         return s;
  194.     }
  195.     private static org.openspcoop2.utils.Semaphore getLockUserInfo(String nomePolicy){
  196.         org.openspcoop2.utils.Semaphore s = _lockUserInfo.get(nomePolicy);
  197.         if(s==null) {
  198.             s = initLockUserInfo(nomePolicy);
  199.         }
  200.         return s;
  201.     } 
  202.     
  203.     private static final Map<String, org.openspcoop2.utils.Semaphore> _lockNegoziazione = new HashMap<>();
  204.     private static synchronized org.openspcoop2.utils.Semaphore initLockNegoziazione(String nomePolicy){
  205.         org.openspcoop2.utils.Semaphore s = _lockNegoziazione.get(nomePolicy);
  206.         if(s==null) {
  207.             Integer permits = OpenSPCoop2Properties.getInstance().getGestioneRetrieveTokenLockPermits();
  208.             if(permits!=null && permits.intValue()>1) {
  209.                 s = new org.openspcoop2.utils.Semaphore("GestoreTokenNegoziazione_"+nomePolicy, permits);
  210.             }
  211.             else {
  212.                 s = new org.openspcoop2.utils.Semaphore("GestoreTokenNegoziazione_"+nomePolicy);
  213.             }
  214.             _lockNegoziazione.put(nomePolicy, s);
  215.         }
  216.         return s;
  217.     }
  218.     private static org.openspcoop2.utils.Semaphore getLockNegoziazione(String nomePolicy){
  219.         org.openspcoop2.utils.Semaphore s = _lockNegoziazione.get(nomePolicy);
  220.         if(s==null) {
  221.             s = initLockNegoziazione(nomePolicy);
  222.         }
  223.         return s;
  224.     } 
  225.     
  226.     private static final Map<String, org.openspcoop2.utils.Semaphore> _lockAttributeAuthority = new HashMap<>();
  227.     private static synchronized org.openspcoop2.utils.Semaphore initLockAttributeAuthority(String nomePolicy){
  228.         org.openspcoop2.utils.Semaphore s = _lockAttributeAuthority.get(nomePolicy);
  229.         if(s==null) {
  230.             Integer permits = OpenSPCoop2Properties.getInstance().getGestioneAttributeAuthorityLockPermits();
  231.             if(permits!=null && permits.intValue()>1) {
  232.                 s = new org.openspcoop2.utils.Semaphore("GestoreTokenAttributeAuthority_"+nomePolicy, permits);
  233.             }
  234.             else {
  235.                 s = new org.openspcoop2.utils.Semaphore("GestoreTokenAttributeAuthority_"+nomePolicy);
  236.             }
  237.             _lockAttributeAuthority.put(nomePolicy, s);
  238.         }
  239.         return s;
  240.     }
  241.     private static org.openspcoop2.utils.Semaphore getLockAttributeAuthority(String nomePolicy){
  242.         org.openspcoop2.utils.Semaphore s = _lockAttributeAuthority.get(nomePolicy);
  243.         if(s==null) {
  244.             s = initLockAttributeAuthority(nomePolicy);
  245.         }
  246.         return s;
  247.     } 
  248.     
  249.     private static final Map<String, org.openspcoop2.utils.Semaphore> _lockGenericToken = new HashMap<>();
  250.     private static synchronized org.openspcoop2.utils.Semaphore initLockGenericToken(String funzione){
  251.         org.openspcoop2.utils.Semaphore s = _lockGenericToken.get(funzione);
  252.         if(s==null) {
  253.             Integer permits = OpenSPCoop2Properties.getInstance().getGestioneRetrieveTokenLockPermits();
  254.             if(permits!=null && permits.intValue()>1) {
  255.                 s = new org.openspcoop2.utils.Semaphore("GestoreGenericTokenCache_"+funzione, permits);
  256.             }
  257.             else {
  258.                 s = new org.openspcoop2.utils.Semaphore("GestoreGenericTokenCache_"+funzione);
  259.             }
  260.             _lockGenericToken.put(funzione, s);
  261.         }
  262.         return s;
  263.     }
  264.     private static org.openspcoop2.utils.Semaphore getLockGenericToken(String nomePolicy){
  265.         org.openspcoop2.utils.Semaphore s = _lockGenericToken.get(nomePolicy);
  266.         if(s==null) {
  267.             s = initLockGenericToken(nomePolicy);
  268.         }
  269.         return s;
  270.     } 
  271.     
  272.  
  273.     

  275.     static final String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss.SSS";

  277.     /** Logger log */
  278.     private static Logger logger = null;
  279.     private static Logger logConsole = OpenSPCoop2Logger.getLoggerOpenSPCoopConsole();
  280.     
  281.     private static void loggerDebug(String msg) {
  282.         GestoreToken.logger.debug(msg);
  283.     }
  284.     private static void loggerInfo(String msg) {
  285.         GestoreToken.logger.info(msg);
  286.     }
  287.     private static void loggerError(String msg) {
  288.         GestoreToken.logger.error(msg);
  289.     }
  290.     private static void loggerError(String msg, Exception e) {
  291.         GestoreToken.logger.error(msg,e);
  292.     }
  293.     private static String getMessageObjectInCache(org.openspcoop2.utils.cache.CacheResponse response, String keyCache, String funzione) {
  294.         return "Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] (method:"+funzione+") in cache.";
  295.     }
  296.     private static String getMessageEccezioneInCache(org.openspcoop2.utils.cache.CacheResponse response, String keyCache, String funzione) {
  297.         return "Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] (method:"+funzione+") in cache.";
  298.     }
  299.     private static final String MESSAGE_ELEMENT_CACHE_NE_OGGETTO_NE_ECCEZIONE = "In cache non è presente ne un oggetto ne un'eccezione.";
  300.     
  301.     static final String TOKEN_NON_VALIDO = "Token non valido";
  302.     static String getMessageTokenNonValido(Exception e) {
  303.         return TOKEN_NON_VALIDO+": "+e.getMessage();
  304.     }
  305.     
  306.     static String getMessageViaProxy(String hostProxy, String portProxy) {
  307.         return " [via Proxy: "+hostProxy+":"+portProxy+"] ";
  308.     }
  309.     
  310.     static String getMessageErroreGovWayProxy(Exception e) {
  311.         return "Configurazione errata per la funzionalità govway-proxy; "+e.getMessage();
  312.     }
  313.     
  314.     static String getMessageConnettoreConnessioneSuccesso(ConnettoreBaseHTTP connettore) {
  315.         return "Connessione completata con successo (codice trasporto: "+connettore.getCodiceTrasporto()+")";
  316.     }
  317.     static String getMessageConnettoreConnessioneErrore(ConnettoreBaseHTTP connettore) {
  318.         return "Connessione terminata con errore (codice trasporto: "+connettore.getCodiceTrasporto()+")";
  319.     }
  320.     static final String CONNETTORE_RISPOSTA_NON_PERVENUTA = "; non è pervenuta alcuna risposta";
  321.     
  322.     public static final String KEY_ALIAS_UNDEFINED = "JWT Signature key alias undefined";
  323.     public static final String KEY_PASSWORD_UNDEFINED = "JWT Signature key password undefined";
  324.     public static final String KEYSTORE_TYPE_UNDEFINED = "JWT Signature keystore type undefined";
  325.     public static final String KEYSTORE_KEYPAIR_UNDEFINED = "JWT Signature keyPair undefined";
  326.     public static final String KEYSTORE_KEYSTORE_UNDEFINED = "JWT Signature keystore undefined";
  327.     public static final String KEYSTORE_KEYSTORE_FILE_UNDEFINED = "JWT Signature keystore file undefined";
  328.     public static final String KEYSTORE_KEYSTORE_PASSWORD_UNDEFINED = "JWT Signature keystore password undefined";
  329.     public static final String KEYSTORE_PRIVATE_KEY_UNDEFINED = "JWT Signature private key file undefined";
  330.     public static final String KEYSTORE_PUBLIC_KEY_UNDEFINED = "JWT Signature public key file undefined";
  331.     public static final String KEYSTORE_KEY_PAIR_ALGORITHM_UNDEFINED = "JWT Signature key pair algorithm undefined";
  332.     
  333.     /** Connettore Utils */
  334.     static void addProperties(ConnettoreMsg connettoreMsg, Properties p) {
  335.         if(p!=null && p.size()>0) {
  336.             Enumeration<?> en = p.propertyNames();
  337.             while (en.hasMoreElements()) {
  338.                 Object oKey = en.nextElement();
  339.                 if(oKey!=null) {
  340.                     String key = (String) oKey;
  341.                     String value = p.getProperty(key);
  342.                     connettoreMsg.getConnectorProperties().put(key,value);
  343.                 }
  344.             }
  345.         }
  346.     }
  347.     
  348.     
  349.     /* --------------- Cache --------------------*/
  350.     private static String getPrefixOggettoConChiave(String key) {
  351.          return "oggetto con chiave ["+key+"]";
  352.     }
  353.     private static String getSuffixEseguiOperazione(String funzione) {
  354.         return " (method:"+funzione+") eseguo operazione...";
  355.     }
  356.     private static String getMessaggioAggiuntaOggettoInCache(String keyCache) {
  357.         return "Aggiungo oggetto ["+keyCache+"] in cache";
  358.     }
  359.     private static String getMessaggioErroreInserimentoInCache(String keyCache, Exception e) {
  360.         return "Errore durante l'inserimento in cache ["+keyCache+"]: "+e.getMessage();
  361.     }
  362.     private static String getMessaggioErroreValoreEsitoNull(String funzione) {
  363.         return "Metodo (GestoreToken."+funzione+") ha ritornato un valore di esito null";
  364.     }
  365.     
  366.     public static void resetGestioneTokenCache() throws TokenException{
  367.         if(GestoreToken.cacheGestioneToken!=null){
  368.             try{
  369.                 GestoreToken.cacheGestioneToken.clear();
  370.             }catch(Exception e){
  371.                 throw new TokenException(e.getMessage(),e);
  372.             }
  373.         }
  374.     }
  375.     public static void resetAttributeAuthorityCache() throws TokenException{
  376.         if(GestoreToken.cacheAttributeAuthority!=null){
  377.             try{
  378.                 GestoreToken.cacheAttributeAuthority.clear();
  379.             }catch(Exception e){
  380.                 throw new TokenException(e.getMessage(),e);
  381.             }
  382.         }
  383.     }
  384.     
  385.     public static String printStatsGestioneTokenCache(String separator) throws TokenException{
  386.         try{
  387.             if(GestoreToken.cacheGestioneToken!=null){
  388.                 return GestoreToken.cacheGestioneToken.printStats(separator);
  389.             }
  390.             else{
  391.                 throw new TokenException(Constants.MSG_CACHE_NON_ABILITATA);
  392.             }
  393.         }catch(Exception e){
  394.             throw new TokenException("Visualizzazione Statistiche riguardante la cache sulla gestione dei token non riuscita: "+e.getMessage(),e);
  395.         }
  396.     }
  397.     public static String printStatsAttributeAuthorityCache(String separator) throws TokenException{
  398.         try{
  399.             if(GestoreToken.cacheAttributeAuthority!=null){
  400.                 return GestoreToken.cacheAttributeAuthority.printStats(separator);
  401.             }
  402.             else{
  403.                 throw new TokenException(Constants.MSG_CACHE_NON_ABILITATA);
  404.             }
  405.         }catch(Exception e){
  406.             throw new TokenException("Visualizzazione Statistiche riguardante la cache sui dati delle Attribute Authority non riuscita: "+e.getMessage(),e);
  407.         }
  408.     }
  409.     
  410.     public static void abilitaGestioneTokenCache() throws TokenException{
  411.         if(GestoreToken.cacheGestioneToken!=null)
  412.             throw new TokenException(Constants.MSG_CACHE_GIA_ABILITATA);
  413.         else{
  414.             abilitaGestioneTokenCacheEngine();
  415.         }
  416.     }
  417.     public static void abilitaAttributeAuthorityCache() throws TokenException{
  418.         if(GestoreToken.cacheAttributeAuthority!=null)
  419.             throw new TokenException(Constants.MSG_CACHE_GIA_ABILITATA);
  420.         else{
  421.             abilitaAttributeAuthorityCacheEngine();
  422.         }
  423.     }
  424.     
  425.     private static synchronized void abilitaGestioneTokenCacheEngine() throws TokenException{
  426.         if(GestoreToken.cacheGestioneToken==null) {
  427.             try{
  428.                 GestoreToken.cacheGestioneToken = new Cache(CacheType.JCS, GestoreToken.GESTIONE_TOKEN_CACHE_NAME); // lascio JCS come default abilitato via jmx
  429.                 GestoreToken.cacheGestioneToken.build();
  430.             }catch(Exception e){
  431.                 throw new TokenException(e.getMessage(),e);
  432.             }
  433.         }
  434.     }
  435.     private static synchronized void abilitaAttributeAuthorityCacheEngine() throws TokenException{
  436.         if(GestoreToken.cacheAttributeAuthority==null) {
  437.             try{
  438.                 GestoreToken.cacheAttributeAuthority = new Cache(CacheType.JCS, GestoreToken.ATTRIBUTE_AUTHORITY_CACHE_NAME); // lascio JCS come default abilitato via jmx
  439.                 GestoreToken.cacheAttributeAuthority.build();
  440.             }catch(Exception e){
  441.                 throw new TokenException(e.getMessage(),e);
  442.             }
  443.         }
  444.     }
  445.     
  446.     public static void abilitaGestioneTokenCache(Long dimensioneCache,Boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond) throws TokenException{
  447.         if(GestoreToken.cacheGestioneToken!=null)
  448.             throw new TokenException(Constants.MSG_CACHE_GIA_ABILITATA);
  449.         else{
  450.             try{
  451.                 setGestioneTokenCache(dimensioneCache, algoritmoCacheLRU, itemIdleTime, itemLifeSecond);
  452.             }catch(Exception e){
  453.                 throw new TokenException(e.getMessage(),e);
  454.             }
  455.         }
  456.     }
  457.     public static void abilitaAttributeAuthorityCache(Long dimensioneCache,Boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond) throws TokenException{
  458.         if(GestoreToken.cacheAttributeAuthority!=null)
  459.             throw new TokenException(Constants.MSG_CACHE_GIA_ABILITATA);
  460.         else{
  461.             try{
  462.                 setAttributeAuthorityCache(dimensioneCache, algoritmoCacheLRU, itemIdleTime, itemLifeSecond);
  463.             }catch(Exception e){
  464.                 throw new TokenException(e.getMessage(),e);
  465.             }
  466.         }
  467.     }
  468.     
  469.     private static void setGestioneTokenCache(Long dimensioneCache,Boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond) throws TokenException, UtilsException{
  470.         int dimensioneCacheInt = -1;
  471.         if(dimensioneCache!=null){
  472.             dimensioneCacheInt = dimensioneCache.intValue();
  473.         }
  474.         
  475.         String algoritmoCache = null;
  476.         if(algoritmoCacheLRU!=null){
  477.             if(algoritmoCacheLRU)
  478.                  algoritmoCache = CostantiConfigurazione.CACHE_LRU.toString();
  479.             else
  480.                  algoritmoCache = CostantiConfigurazione.CACHE_MRU.toString();
  481.         }else{
  482.             algoritmoCache = CostantiConfigurazione.CACHE_LRU.toString();
  483.         }
  484.         
  485.         long itemIdleTimeLong = -1;
  486.         if(itemIdleTime!=null){
  487.             itemIdleTimeLong = itemIdleTime;
  488.         }
  489.         
  490.         long itemLifeSecondLong = -1;
  491.         if(itemLifeSecond!=null){
  492.             itemLifeSecondLong = itemLifeSecond;
  493.         }
  494.         
  495.         GestoreToken.initGestioneTokenCacheToken(CacheType.JCS, dimensioneCacheInt, algoritmoCache, itemIdleTimeLong, itemLifeSecondLong, null); // lascio JCS come default abilitato via jmx
  496.     }
  497.     private static void setAttributeAuthorityCache(Long dimensioneCache,Boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond) throws TokenException, UtilsException{
  498.         int dimensioneCacheInt = -1;
  499.         if(dimensioneCache!=null){
  500.             dimensioneCacheInt = dimensioneCache.intValue();
  501.         }
  502.         
  503.         String algoritmoCache = null;
  504.         if(algoritmoCacheLRU!=null){
  505.             if(algoritmoCacheLRU)
  506.                  algoritmoCache = CostantiConfigurazione.CACHE_LRU.toString();
  507.             else
  508.                  algoritmoCache = CostantiConfigurazione.CACHE_MRU.toString();
  509.         }else{
  510.             algoritmoCache = CostantiConfigurazione.CACHE_LRU.toString();
  511.         }
  512.         
  513.         long itemIdleTimeLong = -1;
  514.         if(itemIdleTime!=null){
  515.             itemIdleTimeLong = itemIdleTime;
  516.         }
  517.         
  518.         long itemLifeSecondLong = -1;
  519.         if(itemLifeSecond!=null){
  520.             itemLifeSecondLong = itemLifeSecond;
  521.         }
  522.         
  523.         GestoreToken.initAttributeAuthorityCacheToken(CacheType.JCS, dimensioneCacheInt, algoritmoCache, itemIdleTimeLong, itemLifeSecondLong, null); // lascio JCS come default abilitato via jmx
  524.     }
  525.     
  526.     public static void disabilitaGestioneTokenCache() throws TokenException{
  527.         if(GestoreToken.cacheGestioneToken==null)
  528.             throw new TokenException(Constants.MSG_CACHE_GIA_DISABILITATA);
  529.         else{
  530.             disabilitaGestioneTokenCacheEngine();
  531.         }
  532.     }
  533.     public static void disabilitaAttributeAuthorityCache() throws TokenException{
  534.         if(GestoreToken.cacheAttributeAuthority==null)
  535.             throw new TokenException(Constants.MSG_CACHE_GIA_DISABILITATA);
  536.         else{
  537.             disabilitaAttributeAuthorityCacheEngine();
  538.         }
  539.     }
  540.     
  541.     private static synchronized void disabilitaGestioneTokenCacheEngine() throws TokenException{
  542.         if(GestoreToken.cacheGestioneToken!=null) {
  543.             try{
  544.                 GestoreToken.cacheGestioneToken.clear();
  545.                 GestoreToken.cacheGestioneToken = null;
  546.             }catch(Exception e){
  547.                 throw new TokenException(e.getMessage(),e);
  548.             }
  549.         }
  550.     }
  551.     private static synchronized void disabilitaAttributeAuthorityCacheEngine() throws TokenException{
  552.         if(GestoreToken.cacheAttributeAuthority!=null) {
  553.             try{
  554.                 GestoreToken.cacheAttributeAuthority.clear();
  555.                 GestoreToken.cacheAttributeAuthority = null;
  556.             }catch(Exception e){
  557.                 throw new TokenException(e.getMessage(),e);
  558.             }
  559.         }
  560.     }
  561.     
  562.     public static boolean isGestioneTokenCacheAbilitata(){
  563.         return GestoreToken.cacheGestioneToken != null;
  564.     }
  565.     public static boolean isAttributeAuthorityCacheAbilitata(){
  566.         return GestoreToken.cacheAttributeAuthority != null;
  567.     }
  568.     
  569.     public static String listKeysGestioneTokenCache(String separator) throws TokenException{
  570.         if(GestoreToken.cacheGestioneToken!=null){
  571.             try{
  572.                 return GestoreToken.cacheGestioneToken.printKeys(separator);
  573.             }catch(Exception e){
  574.                 throw new TokenException(e.getMessage(),e);
  575.             }
  576.         }else{
  577.             throw new TokenException(Constants.MSG_CACHE_NON_ABILITATA);
  578.         }
  579.     }
  580.     public static String listKeysAttributeAuthorityCache(String separator) throws TokenException{
  581.         if(GestoreToken.cacheAttributeAuthority!=null){
  582.             try{
  583.                 return GestoreToken.cacheAttributeAuthority.printKeys(separator);
  584.             }catch(Exception e){
  585.                 throw new TokenException(e.getMessage(),e);
  586.             }
  587.         }else{
  588.             throw new TokenException(Constants.MSG_CACHE_NON_ABILITATA);
  589.         }
  590.     }
  591.     
  592.     public static List<String> keysGestioneTokenCache() throws TokenException{
  593.         if(GestoreToken.cacheGestioneToken!=null){
  594.             try{
  595.                 return GestoreToken.cacheGestioneToken.keys();
  596.             }catch(Exception e){
  597.                 throw new TokenException(e.getMessage(),e);
  598.             }
  599.         }else{
  600.             throw new TokenException(Constants.MSG_CACHE_NON_ABILITATA);
  601.         }
  602.     }
  603.     public static List<String> keysAttributeAuthorityCache() throws TokenException{
  604.         if(GestoreToken.cacheAttributeAuthority!=null){
  605.             try{
  606.                 return GestoreToken.cacheAttributeAuthority.keys();
  607.             }catch(Exception e){
  608.                 throw new TokenException(e.getMessage(),e);
  609.             }
  610.         }else{
  611.             throw new TokenException(Constants.MSG_CACHE_NON_ABILITATA);
  612.         }
  613.     }
  614.     
  615.     public static String getObjectGestioneTokenCache(String key) throws TokenException{
  616.         if(GestoreToken.cacheGestioneToken!=null){
  617.             try{
  618.                 Object o = GestoreToken.cacheGestioneToken.get(key);
  619.                 if(o!=null){
  620.                     return o.toString();
  621.                 }else{
  622.                     return getPrefixOggettoConChiave(key)+" non presente";
  623.                 }
  624.             }catch(Exception e){
  625.                 throw new TokenException(e.getMessage(),e);
  626.             }
  627.         }else{
  628.             throw new TokenException(Constants.MSG_CACHE_NON_ABILITATA);
  629.         }
  630.     }
  631.     public static String getObjectAttributeAuthorityCache(String key) throws TokenException{
  632.         if(GestoreToken.cacheAttributeAuthority!=null){
  633.             try{
  634.                 Object o = GestoreToken.cacheAttributeAuthority.get(key);
  635.                 if(o!=null){
  636.                     return o.toString();
  637.                 }else{
  638.                     return getPrefixOggettoConChiave(key)+" non presente";
  639.                 }
  640.             }catch(Exception e){
  641.                 throw new TokenException(e.getMessage(),e);
  642.             }
  643.         }else{
  644.             throw new TokenException(Constants.MSG_CACHE_NON_ABILITATA);
  645.         }
  646.     }
  647.     
  648.     public static void removeObjectGestioneTokenCache(String key) throws TokenException{
  649.         if(GestoreToken.cacheGestioneToken!=null){
  650.             try{
  651.                 GestoreToken.cacheGestioneToken.remove(key);
  652.             }catch(Exception e){
  653.                 throw new TokenException(e.getMessage(),e);
  654.             }
  655.         }else{
  656.             throw new TokenException(Constants.MSG_CACHE_NON_ABILITATA);
  657.         }
  658.     }
  659.     public static void removeObjectAttributeAuthorityCache(String key) throws TokenException{
  660.         if(GestoreToken.cacheAttributeAuthority!=null){
  661.             try{
  662.                 GestoreToken.cacheAttributeAuthority.remove(key);
  663.             }catch(Exception e){
  664.                 throw new TokenException(e.getMessage(),e);
  665.             }
  666.         }else{
  667.             throw new TokenException(Constants.MSG_CACHE_NON_ABILITATA);
  668.         }
  669.     }
  670.     
  671.     
  672.     
  673.     
  674.     
  675.     /*----------------- CLEANER --------------------*/
  676.     
  677.     public static void removeGenericPropertiesGestioneToken(IDGenericProperties idGP) throws TokenException {
  678.         
  679.         if(GestoreToken.isGestioneTokenCacheAbilitata()){
  680.             
  681.             String prefixKeyValidazioneJwt = null;
  682.             String prefixKeyIntrospection = null;
  683.             String prefixKeyUserInfo = null;
  684.             
  685.             String prefixKeyRetrieveToken = null;
  686.             
  687.             boolean checkKeys = false;
  688.             
  689.             if(CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_VALIDATION.equals(idGP.getTipologia())) {
  690.                 
  691.                 prefixKeyValidazioneJwt = GestoreTokenValidazioneUtilities.buildPrefixCacheKeyValidazione(idGP.getNome(), VALIDAZIONE_JWT_FUNCTION);
  692.                 prefixKeyIntrospection = GestoreTokenValidazioneUtilities.buildPrefixCacheKeyValidazione(idGP.getNome(), INTROSPECTION_FUNCTION);
  693.                 prefixKeyUserInfo = GestoreTokenValidazioneUtilities.buildPrefixCacheKeyValidazione(idGP.getNome(), USERINFO_FUNCTION);
  694.                 
  695.                 checkKeys = true;
  696.             }
  697.             else if(CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_RETRIEVE.equals(idGP.getTipologia())) {
  698.                 
  699.                 prefixKeyRetrieveToken = GestoreTokenNegoziazioneUtilities.buildPrefixCacheKeyNegoziazione(idGP.getNome(), RETRIEVE_FUNCTION);
  700.                 
  701.                 checkKeys = true;
  702.                 
  703.             }
  704.             
  705.             if(checkKeys) {
  706.                 checkKeys(prefixKeyValidazioneJwt, prefixKeyIntrospection, prefixKeyUserInfo,
  707.                         prefixKeyRetrieveToken);
  708.             }
  709.                 
  710.         }
  711.         
  712.     }
  713.     public static void removeGenericPropertiesAttributeAuthority(IDGenericProperties idGP) throws TokenException {
  714.         
  715.         if(GestoreToken.isAttributeAuthorityCacheAbilitata()){
  716.                         
  717.             String prefixKeyAA = null;
  718.             
  719.             boolean checkKeys = false;
  720.             
  721.             if(CostantiConfigurazione.GENERIC_PROPERTIES_ATTRIBUTE_AUTHORITY.equals(idGP.getTipologia())) {
  722.                 
  723.                 prefixKeyAA = GestoreTokenAttributeAuthorityUtilities.buildCacheKeyRecuperoAttributiPrefix(idGP.getNome(), ATTRIBUTE_AUTHORITY_FUNCTION);
  724.                 
  725.                 checkKeys = true;
  726.             }
  727.             
  728.             if(checkKeys) {
  729.                 checkKeys(prefixKeyAA);
  730.             }
  731.                 
  732.         }
  733.         
  734.     }
  735.     private static void checkKeys(String prefixKeyValidazioneJwt, String prefixKeyIntrospection, String prefixKeyUserInfo,
  736.             String prefixKeyRetrieveToken) throws TokenException {
  737.         List<String> keyForClean = new ArrayList<>();
  738.         List<String> keys = GestoreToken.keysGestioneTokenCache();
  739.         if(keys!=null && !keys.isEmpty()) {
  740.             fillKeyForClean(prefixKeyValidazioneJwt, prefixKeyIntrospection, prefixKeyUserInfo,
  741.                     prefixKeyRetrieveToken, null,
  742.                     keys, keyForClean);
  743.         }
  744.         if(!keyForClean.isEmpty()) {
  745.             for (String key : keyForClean) {
  746.                 removeObjectGestioneTokenCache(key);
  747.             }
  748.         }
  749.     }
  750.     private static void checkKeys(String prefixKeyAA) throws TokenException {
  751.         List<String> keyForClean = new ArrayList<>();
  752.         List<String> keys = GestoreToken.keysAttributeAuthorityCache();
  753.         if(keys!=null && !keys.isEmpty()) {
  754.             fillKeyForClean(null, null, null,
  755.                     null, prefixKeyAA,
  756.                     keys, keyForClean);
  757.         }
  758.         if(!keyForClean.isEmpty()) {
  759.             for (String key : keyForClean) {
  760.                 removeObjectAttributeAuthorityCache(key);
  761.             }
  762.         }
  763.     }
  764.     private static void fillKeyForClean(String prefixKeyValidazioneJwt, String prefixKeyIntrospection, String prefixKeyUserInfo,
  765.             String prefixKeyRetrieveToken, String prefixKeyAA,
  766.             List<String> keys, List<String> keyForClean) {
  767.         for (String key : keys) {
  768.             if(key!=null &&
  769.                 (
  770.                         (prefixKeyValidazioneJwt!=null && key.startsWith(prefixKeyValidazioneJwt))
  771.                         ||
  772.                         (prefixKeyIntrospection!=null && key.startsWith(prefixKeyIntrospection))
  773.                         ||
  774.                         (prefixKeyUserInfo!=null && key.startsWith(prefixKeyUserInfo))
  775.                         ||
  776.                         (prefixKeyRetrieveToken!=null && key.startsWith(prefixKeyRetrieveToken))
  777.                         ||
  778.                         (prefixKeyAA!=null && key.startsWith(prefixKeyAA))
  779.                     )
  780.                 ){
  781.                 keyForClean.add(key);
  782.             }
  783.         }
  784.     }
  785.     
  786.     
  787.     
  788.     


  791.     /*----------------- INIZIALIZZAZIONE --------------------*/
  792.     public static void initializeGestioneToken(Logger log) throws TokenException, UtilsException{
  793.         GestoreToken.initializeGestioneToken(null, false, -1,null,-1l,-1l, log);
  794.     }
  795.     public static void initializeGestioneToken(CacheType cacheType,
  796.             int dimensioneCache,String algoritmoCache,
  797.             long idleTime, long itemLifeSecond, Logger log) throws TokenException, UtilsException{
  798.         GestoreToken.initializeGestioneToken(cacheType, true, dimensioneCache,algoritmoCache,idleTime,itemLifeSecond, log);
  799.     }
  800.     private static void initializeGestioneToken(CacheType cacheType,
  801.             boolean cacheAbilitata,int dimensioneCache,String algoritmoCache,
  802.             long idleTime, long itemLifeSecond, Logger log) throws TokenException, UtilsException{

  804.         // Inizializzo log
  805.         GestoreToken.logger = log;
  806.                 
  807.         // Inizializzazione Cache
  808.         if(cacheAbilitata){
  809.             GestoreToken.initGestioneTokenCacheToken(cacheType, dimensioneCache, algoritmoCache, idleTime, itemLifeSecond, log);
  810.         }

  812.     }
  813.     
  814.     public static void initializeAttributeAuthority(Logger log) throws TokenException, UtilsException{
  815.         GestoreToken.initializeAttributeAuthority(null, false, -1,null,-1l,-1l, log);
  816.     }
  817.     public static void initializeAttributeAuthority(CacheType cacheType,
  818.             int dimensioneCache,String algoritmoCache,
  819.             long idleTime, long itemLifeSecond, Logger log) throws TokenException, UtilsException{
  820.         GestoreToken.initializeAttributeAuthority(cacheType, true, dimensioneCache,algoritmoCache,idleTime,itemLifeSecond, log);
  821.     }
  822.     private static void initializeAttributeAuthority(CacheType cacheType,
  823.             boolean cacheAbilitata,int dimensioneCache,String algoritmoCache,
  824.             long idleTime, long itemLifeSecond, Logger log) throws TokenException, UtilsException{

  826.         // Inizializzo log
  827.         GestoreToken.logger = log;
  828.                 
  829.         // Inizializzazione Cache
  830.         if(cacheAbilitata){
  831.             GestoreToken.initAttributeAuthorityCacheToken(cacheType, dimensioneCache, algoritmoCache, idleTime, itemLifeSecond, log);
  832.         }

  834.     }


  837.     public static void initGestioneTokenCacheToken(CacheType cacheType, int dimensioneCache,String algoritmoCache,
  838.             long idleTime, long itemLifeSecond, Logger log) throws TokenException, UtilsException {
  839.         
  840.         if(log!=null)
  841.             log.info("Inizializzazione cache GestioneToken");

  843.         GestoreToken.cacheGestioneToken = new Cache(cacheType, GestoreToken.GESTIONE_TOKEN_CACHE_NAME);

  845.         if( (dimensioneCache>0) ||
  846.                 (algoritmoCache != null) ){

  848.             initGestioneTokenCacheSize(dimensioneCache, algoritmoCache, log);

  850.         }

  852.         if( idleTime > 0  ){
  853.             try{
  854.                 String msg = "Attributo 'IdleTime' (Token) impostato al valore: "+idleTime;
  855.                 if(log!=null)
  856.                     log.info(msg);
  857.                 GestoreToken.logConsole.info(msg);
  858.                 GestoreToken.cacheGestioneToken.setItemIdleTime(idleTime);
  859.             }catch(Exception error){
  860.                 throw new TokenException("Parametro errato per l'attributo 'IdleTime' (Token): "+error.getMessage(),error);
  861.             }
  862.         }
  863.         try{
  864.             String msg = "Attributo 'MaxLifeSecond' (Token) impostato al valore: "+itemLifeSecond;
  865.             if(log!=null)
  866.                 log.info(msg);
  867.             GestoreToken.logConsole.info(msg);
  868.             GestoreToken.cacheGestioneToken.setItemLifeTime(itemLifeSecond);
  869.         }catch(Exception error){
  870.             throw new TokenException("Parametro errato per l'attributo 'MaxLifeSecond' (Token): "+error.getMessage(),error);
  871.         }

  873.         GestoreToken.cacheGestioneToken.build();
  874.     }
  875.     public static void initAttributeAuthorityCacheToken(CacheType cacheType, int dimensioneCache,String algoritmoCache,
  876.             long idleTime, long itemLifeSecond, Logger log) throws TokenException, UtilsException {
  877.         
  878.         if(log!=null)
  879.             log.info("Inizializzazione cache Token");

  881.         GestoreToken.cacheAttributeAuthority = new Cache(cacheType, GestoreToken.ATTRIBUTE_AUTHORITY_CACHE_NAME);

  883.         if( (dimensioneCache>0) ||
  884.                 (algoritmoCache != null) ){

  886.             initCacheSize(dimensioneCache, algoritmoCache, log);

  888.         }

  890.         if( idleTime > 0  ){
  891.             try{
  892.                 String msg = "Attributo 'IdleTime' (AttributeAuthority) impostato al valore: "+idleTime;
  893.                 if(log!=null)
  894.                     log.info(msg);
  895.                 GestoreToken.logConsole.info(msg);
  896.                 GestoreToken.cacheAttributeAuthority.setItemIdleTime(idleTime);
  897.             }catch(Exception error){
  898.                 throw new TokenException("Parametro errato per l'attributo 'IdleTime' (AttributeAuthority): "+error.getMessage(),error);
  899.             }
  900.         }
  901.         try{
  902.             String msg = "Attributo 'MaxLifeSecond' (AttributeAuthority) impostato al valore: "+itemLifeSecond;
  903.             if(log!=null)
  904.                 log.info(msg);
  905.             GestoreToken.logConsole.info(msg);
  906.             GestoreToken.cacheAttributeAuthority.setItemLifeTime(itemLifeSecond);
  907.         }catch(Exception error){
  908.             throw new TokenException("Parametro errato per l'attributo 'MaxLifeSecond' (AttributeAuthority): "+error.getMessage(),error);
  909.         }

  911.         GestoreToken.cacheAttributeAuthority.build();
  912.     }
  913.     
  914.     public static void initGestioneTokenCacheSize(int dimensioneCache,String algoritmoCache, Logger log) throws TokenException {
  915.         if( dimensioneCache>0 ){
  916.             try{
  917.                 String msg = "Dimensione della cache (Token) impostata al valore: "+dimensioneCache;
  918.                 if(log!=null)
  919.                     log.info(msg);
  920.                 GestoreToken.logConsole.info(msg);
  921.                 GestoreToken.cacheGestioneToken.setCacheSize(dimensioneCache);
  922.             }catch(Exception error){
  923.                 throw new TokenException("Parametro errato per la dimensione della cache (Token): "+error.getMessage(),error);
  924.             }
  925.         }
  926.         if(algoritmoCache != null ){
  927.             String msg = "Algoritmo di cache (Token) impostato al valore: "+algoritmoCache;
  928.             if(log!=null)
  929.                 log.info(msg);
  930.             GestoreToken.logConsole.info(msg);
  931.             if(CostantiConfigurazione.CACHE_MRU.toString().equalsIgnoreCase(algoritmoCache))
  932.                 GestoreToken.cacheGestioneToken.setCacheAlgoritm(CacheAlgorithm.MRU);
  933.             else
  934.                 GestoreToken.cacheGestioneToken.setCacheAlgoritm(CacheAlgorithm.LRU);
  935.         }
  936.     }
  937.     public static void initCacheSize(int dimensioneCache,String algoritmoCache, Logger log) throws TokenException {
  938.         if( dimensioneCache>0 ){
  939.             try{
  940.                 String msg = "Dimensione della cache (AttributeAuthority) impostata al valore: "+dimensioneCache;
  941.                 if(log!=null)
  942.                     log.info(msg);
  943.                 GestoreToken.logConsole.info(msg);
  944.                 GestoreToken.cacheAttributeAuthority.setCacheSize(dimensioneCache);
  945.             }catch(Exception error){
  946.                 throw new TokenException("Parametro errato per la dimensione della cache (AttributeAuthority): "+error.getMessage(),error);
  947.             }
  948.         }
  949.         if(algoritmoCache != null ){
  950.             String msg = "Algoritmo di cache (AttributeAuthority) impostato al valore: "+algoritmoCache;
  951.             if(log!=null)
  952.                 log.info(msg);
  953.             GestoreToken.logConsole.info(msg);
  954.             if(CostantiConfigurazione.CACHE_MRU.toString().equalsIgnoreCase(algoritmoCache))
  955.                 GestoreToken.cacheAttributeAuthority.setCacheAlgoritm(CacheAlgorithm.MRU);
  956.             else
  957.                 GestoreToken.cacheAttributeAuthority.setCacheAlgoritm(CacheAlgorithm.LRU);
  958.         }
  959.     }
  960.     
  961.     

  963.     
  964.     
  965.     
  966.     
  967.     // ********* [VALIDAZIONE-TOKEN] VALIDAZIONE CONFIGURAZIONE ****************** */
  968.     
  969.     public static void validazioneConfigurazione(AbstractDatiInvocazione datiInvocazione) throws ProviderException, ProviderValidationException {
  970.         TokenProvider p = new TokenProvider();
  971.         p.validate(datiInvocazione.getPolicyGestioneToken().getProperties());
  972.     }
  973.     
  974.     
  975.     
  976.     
  977.     // ********* [VALIDAZIONE-TOKEN] VERIFICA POSIZIONE TOKEN ****************** */
  978.     
  979.     private static final String INFO_TRASPORTO_NON_PRESENTI = "Informazioni di trasporto non presenti";
  980.     private static final String CONTENENTE_IL_TOKEN = "contenente il token";
  981.     
  982.     public static EsitoPresenzaToken verificaPosizioneToken(AbstractDatiInvocazione datiInvocazione, boolean portaDelegata) {
  983.         
  984.         EsitoPresenzaToken esitoPresenzaToken = null;
  985.         if(portaDelegata) {
  986.             esitoPresenzaToken = new EsitoPresenzaTokenPortaDelegata();
  987.         }
  988.         else {
  989.             esitoPresenzaToken = new EsitoPresenzaTokenPortaApplicativa();
  990.         }
  991.         
  992.         esitoPresenzaToken.setPresente(false);
  993.         try{
  994.             PolicyGestioneToken policyGestioneToken = datiInvocazione.getPolicyGestioneToken();
  995.             String source = policyGestioneToken.getTokenSource();
  996.             

  998.             String token = null;

  1000.             String detailsErrorHeader = null;
  1001.             if(Costanti.POLICY_TOKEN_SOURCE_RFC6750.equals(source) ||
  1002.                     Costanti.POLICY_TOKEN_SOURCE_RFC6750_HEADER.equals(source) ||
  1003.                     Costanti.POLICY_TOKEN_SOURCE_CUSTOM_HEADER.equals(source)) {
  1004.                 if(datiInvocazione.getInfoConnettoreIngresso()==null || 
  1005.                         datiInvocazione.getInfoConnettoreIngresso().getUrlProtocolContext()==null) {
  1006.                     detailsErrorHeader = INFO_TRASPORTO_NON_PRESENTI;
  1007.                 }
  1008.                 else {
  1009.                     URLProtocolContext urlProtocolContext = datiInvocazione.getInfoConnettoreIngresso().getUrlProtocolContext();
  1010.                     if(urlProtocolContext.getHeaders()==null || urlProtocolContext.getHeaders().size()<=0) {
  1011.                         detailsErrorHeader = "Header di trasporto non presenti";
  1012.                     }
  1013.                     if(Costanti.POLICY_TOKEN_SOURCE_RFC6750.equals(source) ||
  1014.                             Costanti.POLICY_TOKEN_SOURCE_RFC6750_HEADER.equals(source)) {
  1015.                         if(urlProtocolContext.getCredential()==null || urlProtocolContext.getCredential().getBearerToken()==null) {
  1016.                             if(urlProtocolContext.getCredential()!=null && urlProtocolContext.getCredential().getUsername()!=null) {
  1017.                                 detailsErrorHeader = "Riscontrato header http '"+HttpConstants.AUTHORIZATION+"' valorizzato tramite autenticazione '"+HttpConstants.AUTHORIZATION_PREFIX_BASIC+
  1018.                                         "'; la configurazione richiede invece la presenza di un token valorizzato tramite autenticazione '"+HttpConstants.AUTHORIZATION_PREFIX_BEARER+"' ";
  1019.                             }
  1020.                             else {
  1021.                                 detailsErrorHeader = "Non è stato riscontrato un header http '"+HttpConstants.AUTHORIZATION+"' valorizzato tramite autenticazione '"+HttpConstants.AUTHORIZATION_PREFIX_BEARER+"' e contenente un token";
  1022.                             }
  1023.                         }
  1024.                         else {
  1025.                             token = urlProtocolContext.getCredential().getBearerToken();
  1026.                             esitoPresenzaToken.setHeaderHttp(HttpConstants.AUTHORIZATION);
  1027.                         }
  1028.                     }
  1029.                     else {
  1030.                         String headerName = policyGestioneToken.getTokenSourceHeaderName();
  1031.                         List<String> values =  urlProtocolContext.getHeaderValues(headerName);
  1032.                         if(values!=null && !values.isEmpty()) {
  1033.                             token = values.get(0);
  1034.                         }
  1035.                         if(token==null) {
  1036.                             detailsErrorHeader = "Non è stato riscontrato l'header http '"+headerName+"' "+CONTENENTE_IL_TOKEN;
  1037.                         }
  1038.                         else if(values.size()>1) {
  1039.                             detailsErrorHeader = "Sono stati rilevati più di un header http '"+headerName+"'";
  1040.                         }
  1041.                         else {
  1042.                             esitoPresenzaToken.setHeaderHttp(headerName);
  1043.                         }
  1044.                     }
  1045.                 }
  1046.             }
  1047.             
  1048.             String detailsErrorUrl = null;
  1049.             if( (token==null && Costanti.POLICY_TOKEN_SOURCE_RFC6750.equals(source)) ||
  1050.                     Costanti.POLICY_TOKEN_SOURCE_RFC6750_URL.equals(source) ||
  1051.                     Costanti.POLICY_TOKEN_SOURCE_CUSTOM_URL.equals(source)) {
  1052.                 if(datiInvocazione.getInfoConnettoreIngresso()==null || 
  1053.                         datiInvocazione.getInfoConnettoreIngresso().getUrlProtocolContext()==null) {
  1054.                     detailsErrorUrl = INFO_TRASPORTO_NON_PRESENTI;
  1055.                 }
  1056.                 else {
  1057.                     URLProtocolContext urlProtocolContext = datiInvocazione.getInfoConnettoreIngresso().getUrlProtocolContext();
  1058.                     if(urlProtocolContext.getParameters()==null || urlProtocolContext.getParameters().size()<=0) {
  1059.                         detailsErrorUrl = "Parametri nella URL non presenti";
  1060.                     }
  1061.                     String propertyUrlName = null;
  1062.                     if(Costanti.POLICY_TOKEN_SOURCE_RFC6750.equals(source) ||
  1063.                             Costanti.POLICY_TOKEN_SOURCE_RFC6750_URL.equals(source)) {
  1064.                         propertyUrlName = Costanti.RFC6750_URI_QUERY_PARAMETER_ACCESS_TOKEN;
  1065.                     }
  1066.                     else {
  1067.                         propertyUrlName = policyGestioneToken.getTokenSourceUrlPropertyName();
  1068.                     }
  1069.                     List<String> values = urlProtocolContext.getParameterValues(propertyUrlName);
  1070.                     if(values!=null && !values.isEmpty()) {
  1071.                         token = values.get(0);
  1072.                     }
  1073.                     if(token==null) {
  1074.                         detailsErrorUrl = "Non è stato riscontrata la proprietà della URL '"+propertyUrlName+"' "+CONTENENTE_IL_TOKEN;
  1075.                     }
  1076.                     else if(values.size()>1) {
  1077.                         detailsErrorHeader = "Sono state rilevate più proprietà della URL '"+propertyUrlName+"'";
  1078.                     }
  1079.                     else {
  1080.                         esitoPresenzaToken.setPropertyUrl(propertyUrlName);
  1081.                     }
  1082.                 }
  1083.             }
  1084.             
  1085.             String detailsErrorForm = null;
  1086.             if( (token==null && Costanti.POLICY_TOKEN_SOURCE_RFC6750.equals(source)) ||
  1087.                     Costanti.POLICY_TOKEN_SOURCE_RFC6750_FORM.equals(source)) {
  1088.                 if(datiInvocazione.getInfoConnettoreIngresso()==null || 
  1089.                         datiInvocazione.getInfoConnettoreIngresso().getUrlProtocolContext()==null ||
  1090.                         datiInvocazione.getInfoConnettoreIngresso().getUrlProtocolContext().getHttpServletRequest()==null) {
  1091.                     detailsErrorForm = INFO_TRASPORTO_NON_PRESENTI;
  1092.                 }
  1093.                 else {
  1094.                     HttpServletRequest httpServletRequest = datiInvocazione.getInfoConnettoreIngresso().getUrlProtocolContext().getHttpServletRequest();
  1095.                     if(httpServletRequest instanceof FormUrlEncodedHttpServletRequest) {
  1096.                         FormUrlEncodedHttpServletRequest form = (FormUrlEncodedHttpServletRequest) httpServletRequest;
  1097.                         List<String> values = form.getFormUrlEncodedParameterValues(Costanti.RFC6750_FORM_PARAMETER_ACCESS_TOKEN);
  1098.                         if(values!=null && !values.isEmpty()) {
  1099.                             token = values.get(0);
  1100.                         }
  1101.                         if(token==null) {
  1102.                             detailsErrorForm = "Non è stato riscontrata la proprietà della Form '"+Costanti.RFC6750_FORM_PARAMETER_ACCESS_TOKEN+"' "+CONTENENTE_IL_TOKEN;
  1103.                         }
  1104.                         else if(values.size()>1) {
  1105.                             detailsErrorHeader = "Sono state rilevate più proprietà della Form '"+Costanti.RFC6750_FORM_PARAMETER_ACCESS_TOKEN+"'";
  1106.                         }
  1107.                         else {
  1108.                             esitoPresenzaToken.setPropertyFormBased(Costanti.RFC6750_FORM_PARAMETER_ACCESS_TOKEN);
  1109.                         }
  1110.                     }
  1111.                     else if(FormUrlEncodedHttpServletRequest.isFormUrlEncodedRequest(httpServletRequest)) {
  1112.                         List<String> values = TransportUtils.getParameterValues(httpServletRequest, Costanti.RFC6750_FORM_PARAMETER_ACCESS_TOKEN);
  1113.                         if(values!=null && !values.isEmpty()) {
  1114.                             token = values.get(0);
  1115.                         }
  1116.                         if(token==null) {
  1117.                             detailsErrorForm = "Non è stato riscontrata la proprietà della Form '"+Costanti.RFC6750_FORM_PARAMETER_ACCESS_TOKEN+"' "+CONTENENTE_IL_TOKEN;
  1118.                         }
  1119.                         else if(values.size()>1) {
  1120.                             detailsErrorHeader = "Sono state rilevate più proprietà della Form '"+Costanti.RFC6750_FORM_PARAMETER_ACCESS_TOKEN+"'";
  1121.                         }
  1122.                         else {
  1123.                             esitoPresenzaToken.setPropertyFormBased(Costanti.RFC6750_FORM_PARAMETER_ACCESS_TOKEN);
  1124.                         }
  1125.                     }
  1126.                     else {
  1127.                         detailsErrorForm = "Non è stato riscontrata la presenza di un contenuto 'Form-Encoded'";
  1128.                     }
  1129.                 }
  1130.             }
  1131.             
  1132.             String detailsError = null;
  1133.             if(detailsErrorHeader!=null) {
  1134.                 if(Costanti.POLICY_TOKEN_SOURCE_RFC6750.equals(source)) {
  1135.                     if(detailsErrorUrl!=null || detailsErrorForm!=null) {
  1136.                         detailsError = "\n";
  1137.                     }
  1138.                     else {
  1139.                         detailsError = "";
  1140.                     }
  1141.                     detailsError = detailsError + "(Authorization Request Header) " +detailsErrorHeader;
  1142.                 }
  1143.                 else {
  1144.                     detailsError = detailsErrorHeader;
  1145.                 }
  1146.             }
  1147.             if(detailsErrorUrl!=null) {
  1148.                 if(Costanti.POLICY_TOKEN_SOURCE_RFC6750.equals(source)) {
  1149.                     if(detailsError!=null) {
  1150.                         detailsError = detailsError+"\n";
  1151.                     }
  1152.                     else {
  1153.                         if(detailsErrorForm!=null) {
  1154.                             detailsError = "\n";
  1155.                         }
  1156.                         else {
  1157.                             detailsError = "";
  1158.                         }
  1159.                     }
  1160.                     detailsError = detailsError + "(URI Query Parameter) " +detailsErrorUrl;
  1161.                 }
  1162.                 else {
  1163.                     detailsError = detailsErrorUrl;
  1164.                 }
  1165.             }
  1166.             if(detailsErrorForm!=null) {
  1167.                 if(Costanti.POLICY_TOKEN_SOURCE_RFC6750.equals(source)) {
  1168.                     if(detailsError!=null) {
  1169.                         detailsError = detailsError+"\n";
  1170.                     }
  1171.                     else {
  1172.                         detailsError = "";
  1173.                     }
  1174.                     detailsError = detailsError + "(Form-Encoded Body Parameter) " +detailsErrorForm;
  1175.                 }
  1176.                 else {
  1177.                     detailsError = detailsErrorForm;
  1178.                 }
  1179.             }
  1180.             
  1181.             
  1182.             if(token!=null) {
  1183.                 esitoPresenzaToken.setToken(token);
  1184.                 esitoPresenzaToken.setPresente(true);
  1185.             }
  1186.             else {
  1187.                 if(detailsError!=null) {
  1188.                     esitoPresenzaToken.setDetails(detailsError);    
  1189.                 }
  1190.                 else {
  1191.                     esitoPresenzaToken.setDetails("Token non individuato tramite la configurazione indicata");  
  1192.                 }
  1193.                 if(policyGestioneToken.isMessageErrorGenerateEmptyMessage()) {
  1194.                     esitoPresenzaToken.setErrorMessage(WWWAuthenticateGenerator.buildErrorMessage(WWWAuthenticateErrorCode.invalid_request, policyGestioneToken.getRealm(), 
  1195.                             policyGestioneToken.isMessageErrorGenerateGenericMessage(), esitoPresenzaToken.getDetails()));              
  1196.                 }
  1197.                 else {
  1198.                     esitoPresenzaToken.setWwwAuthenticateErrorHeader(WWWAuthenticateGenerator.buildHeaderValue(WWWAuthenticateErrorCode.invalid_request, policyGestioneToken.getRealm(), 
  1199.                             policyGestioneToken.isMessageErrorGenerateGenericMessage(), esitoPresenzaToken.getDetails()));
  1200.                 }
  1201.             }
  1202.             
  1203.         }catch(Exception e){
  1204.             esitoPresenzaToken.setDetails(e.getMessage());
  1205.             esitoPresenzaToken.setEccezioneProcessamento(e);
  1206.         }
  1207.         
  1208.         return esitoPresenzaToken;
  1209.     }
  1210.     
  1211.     
  1212.     
  1213.     
  1214.     
  1215.     
  1216.     
  1217.     // ********* [VALIDAZIONE-TOKEN] DYNAMIC DISCOVERY ****************** */
  1218.     
  1219.     public static final String DYNAMIC_DISCOVERY_FUNCTION = "DynamicDiscovery";
  1220.     
  1221.     public static EsitoDynamicDiscovery dynamicDiscovery(Logger log, AbstractDatiInvocazione datiInvocazione, 
  1222.             PdDContext pddContext, IProtocolFactory<?> protocolFactory,
  1223.             EsitoPresenzaToken esitoPresenzaToken, boolean portaDelegata,
  1224.             Busta busta, IDSoggetto idDominio, IDServizio idServizio) throws Exception {
  1225.         EsitoDynamicDiscovery esitoDynamicDiscovery = null;

  1227.         String token = esitoPresenzaToken.getToken();
  1228.         
  1229.         Cache cache = null;
  1230.         if(OpenSPCoop2Properties.getInstance().isGestioneTokenDynamicDiscoveryUseCacheConfig()) {
  1231.             cache = ConfigurazionePdDReader.getCache();
  1232.         }   
  1233.         else {
  1234.             cache = GestoreToken.cacheGestioneToken;
  1235.         }
  1236.         
  1237.         if(cache==null){
  1238.             esitoDynamicDiscovery = GestoreTokenValidazioneUtilities.dynamicDiscoveryEngine(log, datiInvocazione, 
  1239.                     pddContext, protocolFactory,
  1240.                     token, portaDelegata,
  1241.                     busta, idDominio, idServizio);
  1242.         }
  1243.         else{
  1244.             String policyName = datiInvocazione.getPolicyGestioneToken().getName();
  1245.             String endpoint = datiInvocazione.getPolicyGestioneToken().getDynamicDiscoveryEndpoint();
  1246.             String funzione = DYNAMIC_DISCOVERY_FUNCTION;
  1247.             
  1248.             String tokenCache = "";
  1249.             if(OpenSPCoop2Properties.getInstance().isGestioneTokenDynamicDiscoveryKeyCacheUseToken()) {
  1250.                 tokenCache = token;
  1251.             }
  1252.             tokenCache=tokenCache+"_endpoint:"+endpoint;
  1253.             
  1254.             String keyCache = GestoreTokenValidazioneUtilities.buildCacheKeyValidazione(policyName, funzione, portaDelegata, tokenCache);

  1256.             // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  1257.             
  1258.             org.openspcoop2.utils.cache.CacheResponse response = 
  1259.                     (org.openspcoop2.utils.cache.CacheResponse) cache.get(keyCache);
  1260.             if(response != null){
  1261.                 if(response.getObject()!=null){
  1262.                     GestoreToken.loggerDebug(GestoreToken.getMessageObjectInCache(response, keyCache, funzione));
  1263.                     esitoDynamicDiscovery = (EsitoDynamicDiscovery) response.getObject();
  1264.                     esitoDynamicDiscovery.setInCache(true);
  1265.                 }else if(response.getException()!=null){
  1266.                     GestoreToken.loggerDebug(GestoreToken.getMessageEccezioneInCache(response, keyCache, funzione));
  1267.                     throw (Exception) response.getException();
  1268.                 }else{
  1269.                     GestoreToken.loggerError(MESSAGE_ELEMENT_CACHE_NE_OGGETTO_NE_ECCEZIONE);
  1270.                 }
  1271.             }
  1272.             
  1273.             if(esitoDynamicDiscovery==null) {
  1274.                 
  1275.                 String idTransazione = (pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) ? PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext) : null;
  1276.                 org.openspcoop2.utils.Semaphore lockDynamicDiscovery = getLockDynamicDiscovery(policyName);
  1277.                 SemaphoreLock lock = lockDynamicDiscovery.acquire("dynamicDiscovery", idTransazione);
  1278.                 try {
  1279.                     
  1280.                     response = 
  1281.                         (org.openspcoop2.utils.cache.CacheResponse) cache.get(keyCache);
  1282.                     if(response != null){
  1283.                         if(response.getObject()!=null){
  1284.                             GestoreToken.loggerDebug(GestoreToken.getMessageObjectInCache(response, keyCache, funzione));
  1285.                             esitoDynamicDiscovery = (EsitoDynamicDiscovery) response.getObject();
  1286.                             esitoDynamicDiscovery.setInCache(true);
  1287.                         }else if(response.getException()!=null){
  1288.                             GestoreToken.loggerDebug(GestoreToken.getMessageEccezioneInCache(response, keyCache, funzione));
  1289.                             throw (Exception) response.getException();
  1290.                         }else{
  1291.                             GestoreToken.loggerError(MESSAGE_ELEMENT_CACHE_NE_OGGETTO_NE_ECCEZIONE);
  1292.                         }
  1293.                     }
  1294.     
  1295.                     if(esitoDynamicDiscovery==null) {
  1296.                         // Effettuo la query
  1297.                         GestoreToken.loggerDebug(getPrefixOggettoConChiave(keyCache)+getSuffixEseguiOperazione(funzione));
  1298.                         esitoDynamicDiscovery = GestoreTokenValidazioneUtilities.dynamicDiscoveryEngine(log, datiInvocazione, 
  1299.                                 pddContext, protocolFactory,
  1300.                                 token, portaDelegata,
  1301.                                 busta, idDominio, idServizio);
  1302.                             
  1303.                         // Aggiungo la risposta in cache (se esiste una cache)  
  1304.                         // Sempre. Se la risposta non deve essere cachata l'implementazione può in alternativa:
  1305.                         // - impostare una eccezione di processamento (che setta automaticamente noCache a true)
  1306.                         // - impostare il noCache a true
  1307.                         esitoDynamicDiscovery.setInCache(false); // la prima volta che lo recupero sicuramente non era in cache
  1308.                         if(!esitoDynamicDiscovery.isNoCache()){
  1309.                             GestoreToken.loggerInfo(getMessaggioAggiuntaOggettoInCache(keyCache));
  1310.                             try{    
  1311.                                 org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  1312.                                 responseCache.setObject(esitoDynamicDiscovery);
  1313.                                 cache.put(keyCache,responseCache);
  1314.                             }catch(UtilsException e){
  1315.                                 GestoreToken.loggerError(getMessaggioErroreInserimentoInCache(keyCache, e));
  1316.                             }
  1317.                         }
  1318.                     }
  1319.                 }finally {
  1320.                     lockDynamicDiscovery.release(lock, "dynamicDiscovery", idTransazione);
  1321.                 }
  1322.             }
  1323.         }
  1324.         
  1325.         return esitoDynamicDiscovery;
  1326.     }
  1327.     
  1328.     
  1329.     
  1330.     
  1331.     
  1332.     
  1333.     
  1334.     // ********* [VALIDAZIONE-TOKEN] VALIDAZIONE JWT TOKEN ****************** */
  1335.     
  1336.     public static final String VALIDAZIONE_JWT_FUNCTION = "ValidazioneJWT";
  1337.         
  1338.     public static EsitoGestioneToken validazioneJWTToken(Logger log, AbstractDatiInvocazione datiInvocazione, 
  1339.             PdDContext pddContext, IProtocolFactory<?> protocolFactory,
  1340.             EsitoPresenzaToken esitoPresenzaToken, EsitoDynamicDiscovery esitoDynamicDiscovery, boolean portaDelegata,
  1341.             Busta busta, IDSoggetto idDominio, IDServizio idServizio) throws Exception {
  1342.         
  1343.         EsitoGestioneToken esitoGestioneToken = null;
  1344.         
  1345.         String token = esitoPresenzaToken.getToken();
  1346.         DynamicDiscovery dynamicDiscovery = esitoDynamicDiscovery!=null ? esitoDynamicDiscovery.getDynamicDiscovery() : null;
  1347.         
  1348.         if(GestoreToken.cacheGestioneToken==null){
  1349.             esitoGestioneToken = GestoreTokenValidazioneUtilities.validazioneJWTTokenEngine(log, datiInvocazione, esitoPresenzaToken, 
  1350.                     dynamicDiscovery, 
  1351.                     token, portaDelegata, pddContext,
  1352.                     busta, idDominio, idServizio);
  1353.         }
  1354.         else{
  1355.             String policyName = datiInvocazione.getPolicyGestioneToken().getName();
  1356.             String funzione = VALIDAZIONE_JWT_FUNCTION;
  1357.             String keyCache = GestoreTokenValidazioneUtilities.buildCacheKeyValidazione(policyName, funzione, portaDelegata, token);

  1359.             // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  1360.             
  1361.             org.openspcoop2.utils.cache.CacheResponse response = 
  1362.                     (org.openspcoop2.utils.cache.CacheResponse) GestoreToken.cacheGestioneToken.get(keyCache);
  1363.             if(response != null){
  1364.                 if(response.getObject()!=null){
  1365.                     GestoreToken.loggerDebug(GestoreToken.getMessageObjectInCache(response, keyCache, funzione));
  1366.                     esitoGestioneToken = (EsitoGestioneToken) response.getObject();
  1367.                     esitoGestioneToken.setInCache(true);
  1368.                 }else if(response.getException()!=null){
  1369.                     GestoreToken.loggerDebug(GestoreToken.getMessageEccezioneInCache(response, keyCache, funzione));
  1370.                     throw (Exception) response.getException();
  1371.                 }else{
  1372.                     GestoreToken.loggerError(MESSAGE_ELEMENT_CACHE_NE_OGGETTO_NE_ECCEZIONE);
  1373.                 }
  1374.             }
  1375.             
  1376.             if(esitoGestioneToken==null) {
  1377.                 String idTransazione = (pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) ? PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext) : null;
  1378.                 org.openspcoop2.utils.Semaphore lockJWT = getLockJWT(policyName);
  1379.                 SemaphoreLock lock = lockJWT.acquire("validazioneJWTToken", idTransazione);
  1380.                 try {
  1381.                     
  1382.                     response = 
  1383.                         (org.openspcoop2.utils.cache.CacheResponse) GestoreToken.cacheGestioneToken.get(keyCache);
  1384.                     if(response != null){
  1385.                         if(response.getObject()!=null){
  1386.                             GestoreToken.loggerDebug(GestoreToken.getMessageObjectInCache(response, keyCache, funzione));
  1387.                             esitoGestioneToken = (EsitoGestioneToken) response.getObject();
  1388.                             esitoGestioneToken.setInCache(true);
  1389.                         }else if(response.getException()!=null){
  1390.                             GestoreToken.loggerDebug(GestoreToken.getMessageEccezioneInCache(response, keyCache, funzione));
  1391.                             throw (Exception) response.getException();
  1392.                         }else{
  1393.                             GestoreToken.loggerError(MESSAGE_ELEMENT_CACHE_NE_OGGETTO_NE_ECCEZIONE);
  1394.                         }
  1395.                     }
  1396.     
  1397.                     if(esitoGestioneToken==null) {
  1398.                         // Effettuo la query
  1399.                         GestoreToken.loggerDebug(getPrefixOggettoConChiave(keyCache)+getSuffixEseguiOperazione(funzione));
  1400.                         esitoGestioneToken = GestoreTokenValidazioneUtilities.validazioneJWTTokenEngine(log, datiInvocazione, esitoPresenzaToken, 
  1401.                                 dynamicDiscovery, 
  1402.                                 token, portaDelegata, pddContext,
  1403.                                 busta, idDominio, idServizio);
  1404.                             
  1405.                         // Aggiungo la risposta in cache (se esiste una cache)  
  1406.                         // Sempre. Se la risposta non deve essere cachata l'implementazione può in alternativa:
  1407.                         // - impostare una eccezione di processamento (che setta automaticamente noCache a true)
  1408.                         // - impostare il noCache a true
  1409.                         if(esitoGestioneToken!=null){
  1410.                             esitoGestioneToken.setInCache(false); // la prima volta che lo recupero sicuramente non era in cache
  1411.                             if(!esitoGestioneToken.isNoCache()){
  1412.                                 GestoreToken.loggerInfo(getMessaggioAggiuntaOggettoInCache(keyCache));
  1413.                                 try{    
  1414.                                     org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  1415.                                     responseCache.setObject(esitoGestioneToken);
  1416.                                     GestoreToken.cacheGestioneToken.put(keyCache,responseCache);
  1417.                                 }catch(UtilsException e){
  1418.                                     GestoreToken.loggerError(getMessaggioErroreInserimentoInCache(keyCache, e));
  1419.                                 }
  1420.                             }
  1421.                         }else{
  1422.                             throw new TokenException(getMessaggioErroreValoreEsitoNull( funzione));
  1423.                         }
  1424.                     }
  1425.                 }finally {
  1426.                     lockJWT.release(lock, "validazioneJWTToken", idTransazione);
  1427.                 }
  1428.             }
  1429.         }
  1430.         
  1431.         if(esitoGestioneToken.isValido()) {
  1432.             // ricontrollo tutte le date
  1433.             GestoreTokenValidazioneUtilities.validazioneInformazioniToken(true,
  1434.                     log, datiInvocazione, protocolFactory,
  1435.                     esitoGestioneToken, datiInvocazione.getPolicyGestioneToken(), 
  1436.                     datiInvocazione.getPolicyGestioneToken().isValidazioneJWTSaveErrorInCache());
  1437.         }
  1438.         
  1439.         SecurityToken securityToken = null;
  1440.         if(
  1441.                 // esitoGestioneToken.isValido() && se non si genera comunque un security token non si hanno i json recuperati tramite la PDND 
  1442.                 esitoGestioneToken.getRestSecurityToken()!=null) {
  1443.             securityToken = SecurityTokenUtilities.newSecurityToken(pddContext);
  1444.             securityToken.setAccessToken(esitoGestioneToken.getRestSecurityToken());
  1445.         }
  1446.         
  1447.         // enrich PDND Client Info
  1448.         GestoreTokenValidazioneUtilities.validazioneInformazioniTokenEnrichPDNDClientInfo(esitoGestioneToken, datiInvocazione.getPolicyGestioneToken(), 
  1449.                 pddContext, protocolFactory, datiInvocazione, securityToken);
  1450.         
  1451.         return esitoGestioneToken;
  1452.     }
  1453.     
  1454.     
  1455.     
  1456.     
  1457.     
  1458.     
  1459.     
  1460.     // ********* [VALIDAZIONE-TOKEN] INTROSPECTION TOKEN ****************** */
  1461.     
  1462.     public static final String INTROSPECTION_FUNCTION = "Introspection";
  1463.     
  1464.     public static EsitoGestioneToken introspectionToken(Logger log, AbstractDatiInvocazione datiInvocazione, 
  1465.             PdDContext pddContext, IProtocolFactory<?> protocolFactory,
  1466.             EsitoPresenzaToken esitoPresenzaToken, EsitoDynamicDiscovery esitoDynamicDiscovery, boolean portaDelegata,
  1467.             Busta busta, IDSoggetto idDominio, IDServizio idServizio) throws Exception {
  1468.         EsitoGestioneToken esitoGestioneToken = null;
  1469.         
  1470.         String token = esitoPresenzaToken.getToken();
  1471.         DynamicDiscovery dynamicDiscovery = esitoDynamicDiscovery!=null ? esitoDynamicDiscovery.getDynamicDiscovery() : null;
  1472.         
  1473.         if(GestoreToken.cacheGestioneToken==null){
  1474.             esitoGestioneToken = GestoreTokenValidazioneUtilities.introspectionTokenEngine(log, datiInvocazione, 
  1475.                     pddContext, protocolFactory,
  1476.                     dynamicDiscovery, token, portaDelegata,
  1477.                     busta, idDominio, idServizio);
  1478.         }
  1479.         else{
  1480.             String policyName = datiInvocazione.getPolicyGestioneToken().getName();
  1481.             String funzione = INTROSPECTION_FUNCTION;
  1482.             String keyCache = GestoreTokenValidazioneUtilities.buildCacheKeyValidazione(policyName, funzione, portaDelegata, token);

  1484.             // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  1485.             
  1486.             org.openspcoop2.utils.cache.CacheResponse response = 
  1487.                     (org.openspcoop2.utils.cache.CacheResponse) GestoreToken.cacheGestioneToken.get(keyCache);
  1488.             if(response != null){
  1489.                 if(response.getObject()!=null){
  1490.                     GestoreToken.loggerDebug(GestoreToken.getMessageObjectInCache(response, keyCache, funzione));
  1491.                     esitoGestioneToken = (EsitoGestioneToken) response.getObject();
  1492.                     esitoGestioneToken.setInCache(true);
  1493.                 }else if(response.getException()!=null){
  1494.                     GestoreToken.loggerDebug(GestoreToken.getMessageEccezioneInCache(response, keyCache, funzione));
  1495.                     throw (Exception) response.getException();
  1496.                 }else{
  1497.                     GestoreToken.loggerError(MESSAGE_ELEMENT_CACHE_NE_OGGETTO_NE_ECCEZIONE);
  1498.                 }
  1499.             }
  1500.             
  1501.             if(esitoGestioneToken==null) {
  1502.                 
  1503.                 String idTransazione = (pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) ? PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext) : null;
  1504.                 org.openspcoop2.utils.Semaphore lockIntrospection = getLockIntrospection(policyName);
  1505.                 SemaphoreLock lock = lockIntrospection.acquire("introspectionToken", idTransazione);
  1506.                 try {
  1507.                     
  1508.                     response = 
  1509.                         (org.openspcoop2.utils.cache.CacheResponse) GestoreToken.cacheGestioneToken.get(keyCache);
  1510.                     if(response != null){
  1511.                         if(response.getObject()!=null){
  1512.                             GestoreToken.loggerDebug(GestoreToken.getMessageObjectInCache(response, keyCache, funzione));
  1513.                             esitoGestioneToken = (EsitoGestioneToken) response.getObject();
  1514.                             esitoGestioneToken.setInCache(true);
  1515.                         }else if(response.getException()!=null){
  1516.                             GestoreToken.loggerDebug(GestoreToken.getMessageEccezioneInCache(response, keyCache, funzione));
  1517.                             throw (Exception) response.getException();
  1518.                         }else{
  1519.                             GestoreToken.loggerError(MESSAGE_ELEMENT_CACHE_NE_OGGETTO_NE_ECCEZIONE);
  1520.                         }
  1521.                     }
  1522.     
  1523.                     if(esitoGestioneToken==null) {
  1524.                         // Effettuo la query
  1525.                         GestoreToken.loggerDebug(getPrefixOggettoConChiave(keyCache)+getSuffixEseguiOperazione(funzione));
  1526.                         esitoGestioneToken = GestoreTokenValidazioneUtilities.introspectionTokenEngine(log, datiInvocazione, 
  1527.                                 pddContext, protocolFactory,
  1528.                                 dynamicDiscovery, token, portaDelegata,
  1529.                                 busta, idDominio, idServizio);
  1530.                             
  1531.                         // Aggiungo la risposta in cache (se esiste una cache)  
  1532.                         // Sempre. Se la risposta non deve essere cachata l'implementazione può in alternativa:
  1533.                         // - impostare una eccezione di processamento (che setta automaticamente noCache a true)
  1534.                         // - impostare il noCache a true
  1535.                         esitoGestioneToken.setInCache(false); // la prima volta che lo recupero sicuramente non era in cache
  1536.                         if(!esitoGestioneToken.isNoCache()){
  1537.                             GestoreToken.loggerInfo(getMessaggioAggiuntaOggettoInCache(keyCache));
  1538.                             try{    
  1539.                                 org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  1540.                                 responseCache.setObject(esitoGestioneToken);
  1541.                                 GestoreToken.cacheGestioneToken.put(keyCache,responseCache);
  1542.                             }catch(UtilsException e){
  1543.                                 GestoreToken.loggerError(getMessaggioErroreInserimentoInCache(keyCache, e));
  1544.                             }
  1545.                         }
  1546.                     }
  1547.                 }finally {
  1548.                     lockIntrospection.release(lock, "introspectionToken", idTransazione);
  1549.                 }
  1550.             }
  1551.         }
  1552.         
  1553.         if(esitoGestioneToken.isValido()) {
  1554.             // ricontrollo tutte le date
  1555.             GestoreTokenValidazioneUtilities.validazioneInformazioniToken(false,
  1556.                     log, datiInvocazione, protocolFactory,
  1557.                     esitoGestioneToken, datiInvocazione.getPolicyGestioneToken(), 
  1558.                     datiInvocazione.getPolicyGestioneToken().isIntrospectionSaveErrorInCache());
  1559.         }
  1560.         
  1561.         return esitoGestioneToken;
  1562.     }
  1563.     
  1564.     
  1565.     
  1566.     
  1567.     
  1568.     
  1569.     // ********* [VALIDAZIONE-TOKEN] USER INFO TOKEN ****************** */
  1570.     
  1571.     public static final String USERINFO_FUNCTION = "UserInfo";
  1572.     
  1573.     public static EsitoGestioneToken userInfoToken(Logger log, AbstractDatiInvocazione datiInvocazione, 
  1574.             PdDContext pddContext, IProtocolFactory<?> protocolFactory,
  1575.             EsitoPresenzaToken esitoPresenzaToken, EsitoDynamicDiscovery esitoDynamicDiscovery, boolean portaDelegata,
  1576.             Busta busta, IDSoggetto idDominio, IDServizio idServizio) throws Exception {
  1577.         EsitoGestioneToken esitoGestioneToken = null;
  1578.         
  1579.         String token = esitoPresenzaToken.getToken();
  1580.         DynamicDiscovery dynamicDiscovery = esitoDynamicDiscovery!=null ? esitoDynamicDiscovery.getDynamicDiscovery() : null;
  1581.         
  1582.         if(GestoreToken.cacheGestioneToken==null){
  1583.             esitoGestioneToken = GestoreTokenValidazioneUtilities.userInfoTokenEngine(log, datiInvocazione, 
  1584.                     pddContext, protocolFactory,
  1585.                     dynamicDiscovery, token, portaDelegata,
  1586.                     busta, idDominio, idServizio);
  1587.         }
  1588.         else{
  1589.             String policyName = datiInvocazione.getPolicyGestioneToken().getName();
  1590.             String funzione = USERINFO_FUNCTION;
  1591.             String keyCache = GestoreTokenValidazioneUtilities.buildCacheKeyValidazione(policyName, funzione, portaDelegata, token);

  1593.             // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  1594.             
  1595.             org.openspcoop2.utils.cache.CacheResponse response = 
  1596.                     (org.openspcoop2.utils.cache.CacheResponse) GestoreToken.cacheGestioneToken.get(keyCache);
  1597.             if(response != null){
  1598.                 if(response.getObject()!=null){
  1599.                     GestoreToken.loggerDebug(GestoreToken.getMessageObjectInCache(response, keyCache, funzione));
  1600.                     esitoGestioneToken = (EsitoGestioneToken) response.getObject();
  1601.                     esitoGestioneToken.setInCache(true);
  1602.                 }else if(response.getException()!=null){
  1603.                     GestoreToken.loggerDebug(GestoreToken.getMessageEccezioneInCache(response, keyCache, funzione));
  1604.                     throw (Exception) response.getException();
  1605.                 }else{
  1606.                     GestoreToken.loggerError(MESSAGE_ELEMENT_CACHE_NE_OGGETTO_NE_ECCEZIONE);
  1607.                 }
  1608.             }
  1609.             
  1610.             if(esitoGestioneToken==null) {
  1611.                 String idTransazione = (pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) ? PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext) : null;
  1612.                 org.openspcoop2.utils.Semaphore lockUserInfo = getLockUserInfo(policyName);
  1613.                 SemaphoreLock lock = lockUserInfo.acquire("userInfoToken", idTransazione);
  1614.                 try {
  1615.                     
  1616.                     response = 
  1617.                         (org.openspcoop2.utils.cache.CacheResponse) GestoreToken.cacheGestioneToken.get(keyCache);
  1618.                     if(response != null){
  1619.                         if(response.getObject()!=null){
  1620.                             GestoreToken.loggerDebug(GestoreToken.getMessageObjectInCache(response, keyCache, funzione));
  1621.                             esitoGestioneToken = (EsitoGestioneToken) response.getObject();
  1622.                             esitoGestioneToken.setInCache(true);
  1623.                         }else if(response.getException()!=null){
  1624.                             GestoreToken.loggerDebug(GestoreToken.getMessageEccezioneInCache(response, keyCache, funzione));
  1625.                             throw (Exception) response.getException();
  1626.                         }else{
  1627.                             GestoreToken.loggerError(MESSAGE_ELEMENT_CACHE_NE_OGGETTO_NE_ECCEZIONE);
  1628.                         }
  1629.                     }
  1630.     
  1631.                     if(esitoGestioneToken==null) {
  1632.                         // Effettuo la query
  1633.                         GestoreToken.loggerDebug(getPrefixOggettoConChiave(keyCache)+getSuffixEseguiOperazione(funzione));
  1634.                         esitoGestioneToken = GestoreTokenValidazioneUtilities.userInfoTokenEngine(log, datiInvocazione, 
  1635.                                 pddContext, protocolFactory,
  1636.                                 dynamicDiscovery, token, portaDelegata,
  1637.                                 busta, idDominio, idServizio);
  1638.                             
  1639.                         // Aggiungo la risposta in cache (se esiste una cache)  
  1640.                         // Sempre. Se la risposta non deve essere cachata l'implementazione può in alternativa:
  1641.                         // - impostare una eccezione di processamento (che setta automaticamente noCache a true)
  1642.                         // - impostare il noCache a true
  1643.                         esitoGestioneToken.setInCache(false); // la prima volta che lo recupero sicuramente non era in cache
  1644.                         if(!esitoGestioneToken.isNoCache()){
  1645.                             GestoreToken.loggerInfo(getMessaggioAggiuntaOggettoInCache(keyCache));
  1646.                             try{    
  1647.                                 org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  1648.                                 responseCache.setObject(esitoGestioneToken);
  1649.                                 GestoreToken.cacheGestioneToken.put(keyCache,responseCache);
  1650.                             }catch(UtilsException e){
  1651.                                 GestoreToken.loggerError(getMessaggioErroreInserimentoInCache(keyCache, e));
  1652.                             }
  1653.                         }
  1654.                     }
  1655.                 }finally {
  1656.                     lockUserInfo.release(lock, "userInfoToken", idTransazione);
  1657.                 }
  1658.             }
  1659.         }
  1660.         
  1661.         if(esitoGestioneToken.isValido()) {
  1662.             // ricontrollo tutte le date
  1663.             GestoreTokenValidazioneUtilities.validazioneInformazioniToken(false,
  1664.                     log, datiInvocazione, protocolFactory,
  1665.                     esitoGestioneToken, datiInvocazione.getPolicyGestioneToken(), 
  1666.                     datiInvocazione.getPolicyGestioneToken().isUserInfoSaveErrorInCache());
  1667.         }
  1668.         
  1669.         return esitoGestioneToken;
  1670.     }
  1671.     
  1672.     
  1673.     
  1674.     
  1675.     
  1676.     
  1677.     
  1678.     
  1679.     // ********* [VALIDAZIONE-TOKEN] FORWARD TOKEN ****************** */
  1680.     
  1681.     public static void forwardToken(Logger log, String idTransazione, AbstractDatiInvocazione datiInvocazione, EsitoPresenzaToken esitoPresenzaToken, 
  1682.             EsitoGestioneToken esitoValidazioneJWT, EsitoGestioneToken esitoIntrospection, EsitoGestioneToken esitoUserInfo, 
  1683.             InformazioniToken informazioniTokenNormalizzate,
  1684.             boolean portaDelegata,
  1685.             PdDContext pddContext, Busta busta) throws Exception {
  1686.         
  1687.         if(datiInvocazione==null) {
  1688.             throw new CoreException("Dati invocazioni is null");
  1689.         }
  1690.         
  1691.         PolicyGestioneToken policyGestioneToken = datiInvocazione.getPolicyGestioneToken();
  1692.             
  1693.         TokenForward tokenForward = new TokenForward();
  1694.         String token = esitoPresenzaToken.getToken();
  1695.         
  1696.         boolean trasparente = false;
  1697.         String forwardTrasparenteMode = null;
  1698.         String forwardTrasparenteModeHeader = null;
  1699.         String forwardTrasparenteModeUrl = null;
  1700.         if(policyGestioneToken.isForwardToken()) {
  1701.             trasparente = policyGestioneToken.isForwardTokenTrasparente();
  1702.             if(trasparente) {
  1703.                 forwardTrasparenteMode = policyGestioneToken.getForwardTokenTrasparenteMode();
  1704.                 if(Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_AS_RECEIVED.equals(forwardTrasparenteMode)) {
  1705.                     forwardTrasparenteModeHeader = esitoPresenzaToken.getHeaderHttp();
  1706.                     forwardTrasparenteModeUrl = esitoPresenzaToken.getPropertyUrl();
  1707.                 }
  1708.                 else if(Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_RFC6750_HEADER.equals(forwardTrasparenteMode)) {
  1709.                     forwardTrasparenteModeHeader = HttpConstants.AUTHORIZATION;
  1710.                 }
  1711.                 else if(Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_RFC6750_URL.equals(forwardTrasparenteMode)) {
  1712.                     forwardTrasparenteModeUrl = Costanti.RFC6750_URI_QUERY_PARAMETER_ACCESS_TOKEN;
  1713.                 }
  1714.                 else if(Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_CUSTOM_HEADER.equals(forwardTrasparenteMode)) {
  1715.                     forwardTrasparenteModeHeader = policyGestioneToken.getForwardTokenTrasparenteModeCustomHeader();
  1716.                 } 
  1717.                 else if(Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_CUSTOM_URL.equals(forwardTrasparenteMode)) {
  1718.                     forwardTrasparenteModeUrl = policyGestioneToken.getForwardTokenTrasparenteModeCustomUrl();
  1719.                 } 
  1720.             }
  1721.         }
  1722.         
  1723.         boolean infoRaccolte = false;
  1724.         String forwardInformazioniRaccolteMode = null;
  1725.         Properties jwtSecurity = null;
  1726.         boolean encodeBase64 = false;
  1727.         boolean forwardValidazioneJWT = false;  
  1728.         String forwardValidazioneJWTMode = null;
  1729.         String forwardValidazioneJWTName = null;
  1730.         boolean forwardIntrospection = false;   
  1731.         String forwardIntrospectionMode = null;
  1732.         String forwardIntrospectionName = null;
  1733.         boolean forwardUserInfo = false;    
  1734.         String forwardUserInfoMode = null;
  1735.         String forwardUserInfoName = null;
  1736.         if(policyGestioneToken.isForwardToken()) {
  1737.             infoRaccolte = policyGestioneToken.isForwardTokenInformazioniRaccolte();
  1738.             if(infoRaccolte) {
  1739.                 forwardInformazioniRaccolteMode = policyGestioneToken.getForwardTokenInformazioniRaccolteMode();
  1740.                 encodeBase64 = policyGestioneToken.isForwardTokenInformazioniRaccolteEncodeBase64();
  1741.                 if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_OP2_JWS.equals(forwardInformazioniRaccolteMode) ||
  1742.                         Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JWS.equals(forwardInformazioniRaccolteMode)) {
  1743.                     jwtSecurity = policyGestioneToken.getProperties().get(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_SIGNATURE_PROP_REF_ID);
  1744.                 }
  1745.                 else if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JWE.equals(forwardInformazioniRaccolteMode)) {
  1746.                     jwtSecurity = policyGestioneToken.getProperties().get(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_ENCRYP_PROP_REF_ID);
  1747.                 }
  1748.                 
  1749.                 if(jwtSecurity!=null) {
  1750.                     boolean throwError = true;
  1751.                     Map<String,Object> dynamicMap = DynamicMapBuilderUtils.buildDynamicMap(busta, datiInvocazione.getRequestInfo(), pddContext, log);
  1752.                     JOSEUtils.injectKeystore(datiInvocazione.getRequestInfo(), dynamicMap, jwtSecurity, log, throwError); // serve per leggere il keystore dalla cache
  1753.                 }
  1754.                 
  1755.                 forwardValidazioneJWT = policyGestioneToken.isForwardTokenInformazioniRaccolteValidazioneJWT();
  1756.                 if(forwardValidazioneJWT) {
  1757.                     forwardValidazioneJWTMode = policyGestioneToken.getForwardTokenInformazioniRaccolteValidazioneJWTMode();
  1758.                     if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_NO_OPENSPCOOP_CUSTOM_HEADER.equals(forwardValidazioneJWTMode)) {
  1759.                         forwardValidazioneJWTName = policyGestioneToken.getForwardTokenInformazioniRaccolteValidazioneJWTModeHeaderName();
  1760.                     }
  1761.                     else {
  1762.                         forwardValidazioneJWTName = policyGestioneToken.getForwardTokenInformazioniRaccolteValidazioneJWTModeQueryParameterName();
  1763.                     }
  1764.                 }
  1765.                 
  1766.                 forwardIntrospection = policyGestioneToken.isForwardTokenInformazioniRaccolteIntrospection();
  1767.                 if(forwardIntrospection) {
  1768.                     forwardIntrospectionMode = policyGestioneToken.getForwardTokenInformazioniRaccolteIntrospectionMode();
  1769.                     if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_NO_OPENSPCOOP_CUSTOM_HEADER.equals(forwardIntrospectionMode)) {
  1770.                         forwardIntrospectionName = policyGestioneToken.getForwardTokenInformazioniRaccolteIntrospectionModeHeaderName();
  1771.                     }
  1772.                     else {
  1773.                         forwardIntrospectionName = policyGestioneToken.getForwardTokenInformazioniRaccolteIntrospectionModeQueryParameterName();
  1774.                     }
  1775.                 }
  1776.                 
  1777.                 forwardUserInfo = policyGestioneToken.isForwardTokenInformazioniRaccolteUserInfo();
  1778.                 if(forwardUserInfo) {
  1779.                     forwardUserInfoMode = policyGestioneToken.getForwardTokenInformazioniRaccolteUserInfoMode();
  1780.                     if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_NO_OPENSPCOOP_CUSTOM_HEADER.equals(forwardUserInfoMode)) {
  1781.                         forwardUserInfoName = policyGestioneToken.getForwardTokenInformazioniRaccolteUserInfoModeHeaderName();
  1782.                     }
  1783.                     else {
  1784.                         forwardUserInfoName = policyGestioneToken.getForwardTokenInformazioniRaccolteUserInfoModeQueryParameterName();
  1785.                     }
  1786.                 }
  1787.             }
  1788.         }
  1789.         
  1790.         // Elimino token ricevuto
  1791.         boolean delete = GestoreTokenValidazioneUtilities.deleteTokenReceived(datiInvocazione, esitoPresenzaToken, trasparente, forwardTrasparenteModeHeader, forwardTrasparenteModeUrl);
  1792.         boolean soap = datiInvocazione!=null && datiInvocazione.getMessage()!=null && org.openspcoop2.message.constants.ServiceBinding.SOAP.equals(datiInvocazione.getMessage().getServiceBinding());
  1793.         
  1794.         if(trasparente && 
  1795.                 (
  1796.                         delete // eventualmente effettuo il forward di altri header
  1797.                         || 
  1798.                         soap // anche gli header originali non vengono inoltrati
  1799.                 )
  1800.         ) {
  1801.             
  1802.             // Forward trasparente
  1803.             
  1804.             // la delete ha tenuto conto dell'opzione di forward prima di eliminare
  1805.             GestoreTokenValidazioneUtilities.forwardTokenTrasparenteEngine(token, esitoPresenzaToken, tokenForward, forwardTrasparenteMode, forwardTrasparenteModeHeader, forwardTrasparenteModeUrl);
  1806.         }
  1807.         
  1808.         if(infoRaccolte) {
  1809.             
  1810.             // Forward informazioni raccolte
  1811.             
  1812.             GestoreTokenValidazioneUtilities.forwardInfomazioniRaccolteEngine(portaDelegata, idTransazione, tokenForward, 
  1813.                     esitoValidazioneJWT, esitoIntrospection, esitoUserInfo, 
  1814.                     informazioniTokenNormalizzate,
  1815.                     forwardInformazioniRaccolteMode, jwtSecurity, encodeBase64, 
  1816.                     forwardValidazioneJWT, forwardValidazioneJWTMode, forwardValidazioneJWTName,
  1817.                     forwardIntrospection, forwardIntrospectionMode, forwardIntrospectionName,
  1818.                     forwardUserInfo, forwardUserInfoMode, forwardUserInfoName);
  1819.             
  1820.         }
  1821.         
  1822.         // Imposto token forward nel messaggio
  1823.         if(tokenForward.getUrl().size()>0 || tokenForward.getTrasporto().size()>0) {
  1824.             datiInvocazione.getMessage().addContextProperty(Costanti.MSG_CONTEXT_TOKEN_FORWARD, tokenForward);
  1825.         }

  1827.     }

  1829.     public static List<InformazioniToken> getInformazioniTokenValide(EsitoGestioneToken esitoValidazioneJWT, EsitoGestioneToken esitoIntrospection, EsitoGestioneToken esitoUserInfo){
  1830.         List<InformazioniToken> list = new ArrayList<>();
  1831.         if(esitoValidazioneJWT!=null && esitoValidazioneJWT.isValido() && esitoValidazioneJWT.getInformazioniToken()!=null) {
  1832.             list.add(esitoValidazioneJWT.getInformazioniToken());
  1833.         }
  1834.         if(esitoIntrospection!=null && esitoIntrospection.isValido() && esitoIntrospection.getInformazioniToken()!=null) {
  1835.             list.add(esitoIntrospection.getInformazioniToken());
  1836.         }
  1837.         if(esitoUserInfo!=null && esitoUserInfo.isValido() && esitoUserInfo.getInformazioniToken()!=null) {
  1838.             list.add(esitoUserInfo.getInformazioniToken());
  1839.         }
  1840.         return list;
  1841.     }
  1842.     
  1843.     public static List<InformazioniToken> getInformazioniTokenNonValide(EsitoGestioneToken esitoValidazioneJWT, EsitoGestioneToken esitoIntrospection, EsitoGestioneToken esitoUserInfo){
  1844.         
  1845.         // A differenza del metodo sopra non si controlla che il token sia valido.
  1846.         
  1847.         List<InformazioniToken> list = new ArrayList<>();
  1848.         if(esitoValidazioneJWT!=null && esitoValidazioneJWT.getInformazioniToken()!=null) {
  1849.             list.add(esitoValidazioneJWT.getInformazioniToken());
  1850.         }
  1851.         if(esitoIntrospection!=null && esitoIntrospection.getInformazioniToken()!=null) {
  1852.             list.add(esitoIntrospection.getInformazioniToken());
  1853.         }
  1854.         if(esitoUserInfo!=null && esitoUserInfo.getInformazioniToken()!=null) {
  1855.             list.add(esitoUserInfo.getInformazioniToken());
  1856.         }
  1857.         return list;
  1858.     }
  1859.     
  1860.     public static InformazioniToken normalizeInformazioniToken(List<InformazioniToken> list) throws Exception {
  1861.         if(list.size()==1) {
  1862.             return list.get(0);
  1863.         }
  1864.         else {
  1865.             return new InformazioniToken(OpenSPCoop2Properties.getInstance().isGestioneTokenSaveSourceTokenInfo(), list.toArray(new InformazioniToken[1]));
  1866.         }
  1867.     }
  1868.     
  1869.     
  1870.     
  1871.     
  1872.     
  1873.     
  1874.     
  1875.     
  1876.     
  1877.     
  1878.     // ********* [NEGOZIAZIONE-TOKEN] VALIDAZIONE CONFIGURAZIONE ****************** */
  1879.     
  1880.     public static void validazioneConfigurazione(PolicyNegoziazioneToken policyNegoziazioneToken) throws ProviderException, ProviderValidationException {
  1881.         NegoziazioneTokenProvider p = new NegoziazioneTokenProvider();
  1882.         p.validate(policyNegoziazioneToken.getProperties());
  1883.     }
  1884.     
  1885.     
  1886.     // ********* [NEGOZIAZIONE-TOKEN] ENDPOINT TOKEN ****************** */
  1887.     
  1888.     public static final String RETRIEVE_FUNCTION = "Negoziazione";
  1889.         
  1890.     public static EsitoNegoziazioneToken endpointToken(boolean debug, Logger log, PolicyNegoziazioneToken policyNegoziazioneToken, 
  1891.             Busta busta, RequestInfo requestInfo, TipoPdD tipoPdD, String idModulo, PortaApplicativa pa, PortaDelegata pd,
  1892.             PdDContext pddContext, IProtocolFactory<?> protocolFactory) throws Exception {
  1893.         return endpointTokenEngine(debug, log, policyNegoziazioneToken, 
  1894.                 busta, requestInfo, tipoPdD, idModulo, pa, pd,
  1895.                 pddContext,  protocolFactory,
  1896.                 false, null,
  1897.                 null);
  1898.     }
  1899.     private static EsitoNegoziazioneToken endpointTokenEngine(boolean debug, Logger log, PolicyNegoziazioneToken policyNegoziazioneToken, 
  1900.             Busta busta, RequestInfo requestInfo, TipoPdD tipoPdD, String idModulo, PortaApplicativa pa, PortaDelegata pd,
  1901.             PdDContext pddContext, IProtocolFactory<?> protocolFactory,
  1902.             boolean rinegozia, InformazioniNegoziazioneToken previousToken,
  1903.             InformazioniNegoziazioneToken_DatiRichiesta datiRichiesta) throws Exception {
  1904.         EsitoNegoziazioneToken esitoNegoziazioneToken = null;
  1905.         boolean riavviaNegoziazione = rinegozia;
  1906.         riavviaNegoziazione = false;
  1907.         
  1908.         IState state = null;
  1909.         boolean delegata = TipoPdD.DELEGATA.equals(tipoPdD);
  1910.         IDSoggetto idDominio = null;
  1911.         IDServizio idServizio = null;
  1912.         if(busta!=null) {
  1913.             if(delegata) {
  1914.                 if(busta.getTipoMittente()!=null && busta.getMittente()!=null) {
  1915.                     idDominio = new IDSoggetto(busta.getTipoMittente(), busta.getMittente());
  1916.                 }
  1917.             }
  1918.             else {
  1919.                 if(busta.getTipoDestinatario()!=null && busta.getDestinatario()!=null) {
  1920.                     idDominio = new IDSoggetto(busta.getTipoDestinatario(), busta.getDestinatario());
  1921.                 }
  1922.             }
  1923.             if(busta.getTipoDestinatario()!=null && busta.getDestinatario()!=null && 
  1924.                     busta.getTipoServizio()!=null && busta.getServizio()!=null && busta.getVersioneServizio()!=null) {
  1925.                 idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(busta.getTipoServizio(), busta.getServizio(), 
  1926.                         busta.getTipoDestinatario(), busta.getDestinatario(), 
  1927.                         busta.getVersioneServizio());   
  1928.             }
  1929.         }
  1930.         
  1931.         String idTransazione = (pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) ? PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext) : null;
  1932.         OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  1933.         if(datiRichiesta==null && op2Properties.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequest()) {
  1934.             datiRichiesta = new InformazioniNegoziazioneToken_DatiRichiesta();
  1935.             datiRichiesta.setPolicy(policyNegoziazioneToken.getName());
  1936.             datiRichiesta.setTransactionId(idTransazione);
  1937.             if(op2Properties.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequestDate()) {
  1938.                 datiRichiesta.setPrepareRequest(DateManager.getDate()); 
  1939.             }
  1940.         }
  1941.         
  1942.         Map<String, Object> dynamicMap = GestoreTokenNegoziazioneUtilities.buildDynamicNegoziazioneTokenMap(busta, requestInfo, pddContext, log);
  1943.         NegoziazioneTokenDynamicParameters dynamicParameters = new NegoziazioneTokenDynamicParameters(dynamicMap, 
  1944.                 pddContext, requestInfo, busta, state, protocolFactory, 
  1945.                 policyNegoziazioneToken);
  1946.         
  1947.         if(GestoreToken.cacheGestioneToken==null){
  1948.             esitoNegoziazioneToken = GestoreTokenNegoziazioneUtilities.endpointTokenEngine(debug, log, policyNegoziazioneToken, 
  1949.                     busta, requestInfo, tipoPdD,
  1950.                     dynamicParameters, protocolFactory, 
  1951.                     state, delegata, idModulo, pa, pd,
  1952.                     idDominio, idServizio,
  1953.                     previousToken,
  1954.                     datiRichiesta);
  1955.             
  1956.             if(esitoNegoziazioneToken!=null && esitoNegoziazioneToken.isValido()) {
  1957.                 // ricontrollo tutte le date (l'ho appena preso, dovrebbero essere buone) 
  1958.                 boolean checkPerRinegoziazione = false;
  1959.                 GestoreTokenNegoziazioneUtilities.validazioneInformazioniNegoziazioneToken(checkPerRinegoziazione, esitoNegoziazioneToken,  
  1960.                         policyNegoziazioneToken.isSaveErrorInCache());
  1961.             }
  1962.             
  1963.         }
  1964.         else{
  1965.             String policyName = policyNegoziazioneToken.getName();
  1966.             String funzione = RETRIEVE_FUNCTION;
  1967.             String keyCache = GestoreTokenNegoziazioneUtilities.buildCacheKeyNegoziazione(policyName, funzione, delegata, dynamicParameters);

  1969.             // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  1970.             
  1971.             org.openspcoop2.utils.cache.CacheResponse response = 
  1972.                     (org.openspcoop2.utils.cache.CacheResponse) GestoreToken.cacheGestioneToken.get(keyCache);
  1973.             if(response != null){
  1974.                 if(response.getObject()!=null){
  1975.                     GestoreToken.loggerDebug(GestoreToken.getMessageObjectInCache(response, keyCache, funzione));
  1976.                     esitoNegoziazioneToken = (EsitoNegoziazioneToken) response.getObject();
  1977.                     esitoNegoziazioneToken.setInCache(true);
  1978.                 }else if(response.getException()!=null){
  1979.                     GestoreToken.loggerDebug(GestoreToken.getMessageEccezioneInCache(response, keyCache, funzione));
  1980.                     throw (Exception) response.getException();
  1981.                 }else{
  1982.                     GestoreToken.loggerError(MESSAGE_ELEMENT_CACHE_NE_OGGETTO_NE_ECCEZIONE);
  1983.                 }
  1984.             }
  1985.             
  1986.             if(esitoNegoziazioneToken==null) {
  1987.                 org.openspcoop2.utils.Semaphore lockNegoziazione = getLockNegoziazione(policyName);
  1988.                 SemaphoreLock lock = lockNegoziazione.acquire("endpointToken", idTransazione);
  1989.                 try {
  1990.                     
  1991.                     response = 
  1992.                         (org.openspcoop2.utils.cache.CacheResponse) GestoreToken.cacheGestioneToken.get(keyCache);
  1993.                     if(response != null){
  1994.                         if(response.getObject()!=null){
  1995.                             GestoreToken.loggerDebug(GestoreToken.getMessageObjectInCache(response, keyCache, funzione));
  1996.                             esitoNegoziazioneToken = (EsitoNegoziazioneToken) response.getObject();
  1997.                             esitoNegoziazioneToken.setInCache(true);
  1998.                         }else if(response.getException()!=null){
  1999.                             GestoreToken.loggerDebug(GestoreToken.getMessageEccezioneInCache(response, keyCache, funzione));
  2000.                             throw (Exception) response.getException();
  2001.                         }else{
  2002.                             GestoreToken.loggerError(MESSAGE_ELEMENT_CACHE_NE_OGGETTO_NE_ECCEZIONE);
  2003.                         }
  2004.                     }
  2005.     
  2006.                     if(esitoNegoziazioneToken==null) {
  2007.                         // Effettuo la query
  2008.                         GestoreToken.loggerDebug(getPrefixOggettoConChiave(keyCache)+getSuffixEseguiOperazione(funzione));
  2009.                         esitoNegoziazioneToken = GestoreTokenNegoziazioneUtilities.endpointTokenEngine(debug, log, policyNegoziazioneToken, 
  2010.                                 busta, requestInfo, tipoPdD,
  2011.                                 dynamicParameters, protocolFactory, 
  2012.                                 state, delegata, idModulo, pa, pd,
  2013.                                 idDominio, idServizio,
  2014.                                 previousToken,
  2015.                                 datiRichiesta);
  2016.                             
  2017.                         // Aggiungo la risposta in cache (se esiste una cache)  
  2018.                         // Sempre. Se la risposta non deve essere cachata l'implementazione può in alternativa:
  2019.                         // - impostare una eccezione di processamento (che setta automaticamente noCache a true)
  2020.                         // - impostare il noCache a true
  2021.                         if(esitoNegoziazioneToken!=null){ // altrimenti lo mettero' in cache al giro dopo.
  2022.                             esitoNegoziazioneToken.setInCache(false); // la prima volta che lo recupero sicuramente non era in cache
  2023.                             if(!esitoNegoziazioneToken.isNoCache()){
  2024.                                 GestoreToken.loggerInfo(getMessaggioAggiuntaOggettoInCache(keyCache));
  2025.                                 try{    
  2026.                                     org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  2027.                                     responseCache.setObject(esitoNegoziazioneToken);
  2028.                                     GestoreToken.cacheGestioneToken.put(keyCache,responseCache);
  2029.                                 }catch(UtilsException e){
  2030.                                     GestoreToken.loggerError(getMessaggioErroreInserimentoInCache(keyCache, e));
  2031.                                 }
  2032.                             }
  2033.                         }else{
  2034.                             throw new TokenException(getMessaggioErroreValoreEsitoNull( funzione));
  2035.                         }
  2036.                         
  2037.                         if(esitoNegoziazioneToken.isValido()) {
  2038.                             // ricontrollo tutte le date (l'ho appena preso, dovrebbero essere buone) 
  2039.                             boolean checkPerRinegoziazione = false;
  2040.                             GestoreTokenNegoziazioneUtilities.validazioneInformazioniNegoziazioneToken(checkPerRinegoziazione, esitoNegoziazioneToken,  
  2041.                                     policyNegoziazioneToken.isSaveErrorInCache());
  2042.                         }
  2043.                     }
  2044.                     else {
  2045.                     
  2046.                         // l'ho preso in cache
  2047.                         
  2048.                         if(esitoNegoziazioneToken.isValido()) {
  2049.                             // controllo la data qua
  2050.                             boolean checkPerRinegoziazione = true;
  2051.                             GestoreTokenNegoziazioneUtilities.validazioneInformazioniNegoziazioneToken(checkPerRinegoziazione, esitoNegoziazioneToken,  
  2052.                                     policyNegoziazioneToken.isSaveErrorInCache());
  2053.                             if(!esitoNegoziazioneToken.isValido() && !esitoNegoziazioneToken.isDateValide()) {
  2054.                                 // DEVO riavviare la negoziazione poichè è scaduto
  2055.                                 GestoreToken.cacheGestioneToken.remove(keyCache);
  2056.                                 riavviaNegoziazione = true;
  2057.                                 /** System.out.println("Riavvia negoziazione"); */
  2058.                             }
  2059.                         }
  2060.                         
  2061.                     }
  2062.                     
  2063.                 }finally {
  2064.                     // fine synchronized
  2065.                     lockNegoziazione.release(lock, "endpointToken", idTransazione);
  2066.                 }
  2067.             }
  2068.             else {
  2069.                 
  2070.                 // l'ho preso in cache
  2071.                 
  2072.                 if(esitoNegoziazioneToken.isValido()) {
  2073.                     // controllo la data qua
  2074.                     boolean checkPerRinegoziazione = true;
  2075.                     GestoreTokenNegoziazioneUtilities.validazioneInformazioniNegoziazioneToken(checkPerRinegoziazione, esitoNegoziazioneToken,  
  2076.                             policyNegoziazioneToken.isSaveErrorInCache());
  2077.                     if(!esitoNegoziazioneToken.isValido() && !esitoNegoziazioneToken.isDateValide()) {
  2078.                         
  2079.                         org.openspcoop2.utils.Semaphore lockNegoziazione = getLockNegoziazione(policyName);
  2080.                         SemaphoreLock lock = lockNegoziazione.acquire("removeToken", idTransazione);
  2081.                         try {
  2082.                             // DEVO riavviare la negoziazione poichè è scaduto
  2083.                             GestoreToken.cacheGestioneToken.remove(keyCache);
  2084.                             riavviaNegoziazione = true;
  2085.                             /** System.out.println("Riavvia negoziazione"); */
  2086.                         }finally {
  2087.                             // fine synchronized
  2088.                             lockNegoziazione.release(lock, "removeToken", idTransazione);
  2089.                         }
  2090.                     }
  2091.                 }
  2092.                 
  2093.             }
  2094.         }
  2095.         
  2096.         if(riavviaNegoziazione) {
  2097.             return endpointTokenEngine(debug, log, policyNegoziazioneToken, 
  2098.                     busta, requestInfo, tipoPdD, idModulo, pa, pd,
  2099.                     pddContext, protocolFactory,
  2100.                     riavviaNegoziazione, esitoNegoziazioneToken.getInformazioniNegoziazioneToken(),// refresh
  2101.                     datiRichiesta); 
  2102.         }
  2103.         
  2104.         try {
  2105.             if(idTransazione!=null) {
  2106.                 Transaction t = TransactionContext.getTransaction(idTransazione);
  2107.                 if(esitoNegoziazioneToken!=null) {
  2108.                     t.setInformazioniNegoziazioneToken(esitoNegoziazioneToken.getInformazioniNegoziazioneToken());
  2109.                 }
  2110.             }
  2111.         }catch(Exception t) {
  2112.             // ignore
  2113.         }
  2114.         
  2115.         return esitoNegoziazioneToken;
  2116.     }
  2117.     

  2119.     
  2120.     
  2121.     
  2122.     
  2123.     
  2124.     
  2125.     
  2126.     
  2127.     
  2128.     
  2129.     
  2130.     // ********* [ATTRIBUTE AUTHORITY] VALIDAZIONE CONFIGURAZIONE ****************** */
  2131.     
  2132.     public static void validazioneConfigurazione(PolicyAttributeAuthority policyAttributeAuthority) throws ProviderException, ProviderValidationException {
  2133.         AttributeAuthorityProvider p = new AttributeAuthorityProvider();
  2134.         p.validate(policyAttributeAuthority.getProperties());
  2135.     }
  2136.     
  2137.     
  2138.     // ********* [ATTRIBUTE AUTHORITY] ENDPOINT TOKEN ****************** */
  2139.     
  2140.     public static final String ATTRIBUTE_AUTHORITY_FUNCTION = "AttributeAuthority";
  2141.     
  2142.     public static EsitoRecuperoAttributi readAttributes(Logger log, org.openspcoop2.pdd.core.token.attribute_authority.AbstractDatiInvocazione datiInvocazione,
  2143.             PdDContext pddContext, IProtocolFactory<?> protocolFactory,
  2144.             boolean portaDelegata,
  2145.             IDSoggetto idDominio, IDServizio idServizio) throws Exception {
  2146.         EsitoRecuperoAttributi esitoRecuperoAttributi = null;
  2147.         boolean riavviaNegoziazione = false;
  2148.             
  2149.         PolicyAttributeAuthority policyAttributeAuthority = datiInvocazione.getPolicyAttributeAuthority();
  2150.         OpenSPCoop2Message message = datiInvocazione.getMessage();
  2151.         Busta busta = datiInvocazione.getBusta();
  2152.         RequestInfo requestInfo = datiInvocazione.getRequestInfo(); 
  2153.         
  2154.         Map<String, Object> dynamicMap = GestoreTokenAttributeAuthorityUtilities.buildDynamicAAMap(message, busta, requestInfo, pddContext, log,
  2155.                 policyAttributeAuthority.getName(), datiInvocazione);
  2156.         AttributeAuthorityDynamicParameters dynamicParameters = new AttributeAuthorityDynamicParameters(dynamicMap, pddContext, requestInfo, policyAttributeAuthority);
  2157.         
  2158.         ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(datiInvocazione.getState());
  2159.         
  2160.         PortaApplicativa pa = null;
  2161.         PortaDelegata pd = null;
  2162.         if(datiInvocazione instanceof DatiInvocazionePortaApplicativa) {
  2163.             pa = ((DatiInvocazionePortaApplicativa)datiInvocazione).getPa();
  2164.         }
  2165.         else if(datiInvocazione instanceof DatiInvocazionePortaDelegata) {
  2166.             pd = ((DatiInvocazionePortaDelegata)datiInvocazione).getPd();
  2167.         }
  2168.         
  2169.         if(GestoreToken.cacheAttributeAuthority==null){
  2170.                         
  2171.             boolean addIdAndDate = true;
  2172.             String request = GestoreTokenAttributeAuthorityUtilities.buildDynamicAARequest(configurazionePdDManager,  
  2173.                     protocolFactory, requestInfo, 
  2174.                     policyAttributeAuthority, dynamicParameters, addIdAndDate);
  2175.             
  2176.             esitoRecuperoAttributi = GestoreTokenAttributeAuthorityUtilities.readAttributes(log, policyAttributeAuthority, 
  2177.                     protocolFactory,
  2178.                     dynamicParameters,
  2179.                     request, portaDelegata, 
  2180.                     pddContext, datiInvocazione.getBusta(),
  2181.                     datiInvocazione.getIdModulo(), pa, pd,
  2182.                     datiInvocazione.getState(),
  2183.                     idDominio, idServizio,
  2184.                     requestInfo);
  2185.             
  2186.             if(esitoRecuperoAttributi!=null && esitoRecuperoAttributi.isValido()) {
  2187.                 // ricontrollo tutte le date (l'ho appena preso, dovrebbero essere buone) 
  2188.                 GestoreTokenAttributeAuthorityUtilities.validazioneInformazioniAttributiRecuperati(esitoRecuperoAttributi, policyAttributeAuthority, 
  2189.                         policyAttributeAuthority.isSaveErrorInCache(),
  2190.                         dynamicParameters);
  2191.             }
  2192.             
  2193.         }
  2194.         else{
  2195.             String funzione = ATTRIBUTE_AUTHORITY_FUNCTION;
  2196.             
  2197.             boolean addIdAndDate = true;
  2198.             
  2199.             // Aggiungo anche la richiesta poichè può venire costruita con freemarker o template e quindi può essere dinamica a sua volta (non considero però le date)
  2200.             String requestKeyCache = GestoreTokenAttributeAuthorityUtilities.buildDynamicAARequest(configurazionePdDManager, 
  2201.                     protocolFactory, requestInfo, 
  2202.                     policyAttributeAuthority, dynamicParameters, !addIdAndDate);
  2203.             
  2204.             String aaName = policyAttributeAuthority.getName();
  2205.             String keyCache = GestoreTokenAttributeAuthorityUtilities.buildCacheKeyRecuperoAttributi(aaName, funzione, portaDelegata, dynamicParameters, requestKeyCache);

  2207.             // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  2208.             
  2209.             org.openspcoop2.utils.cache.CacheResponse response = 
  2210.                     (org.openspcoop2.utils.cache.CacheResponse) GestoreToken.cacheAttributeAuthority.get(keyCache);
  2211.             if(response != null){
  2212.                 if(response.getObject()!=null){
  2213.                     GestoreToken.loggerDebug(GestoreToken.getMessageObjectInCache(response, keyCache, funzione));
  2214.                     esitoRecuperoAttributi = (EsitoRecuperoAttributi) response.getObject();
  2215.                     esitoRecuperoAttributi.setInCache(true);
  2216.                 }else if(response.getException()!=null){
  2217.                     GestoreToken.loggerDebug(GestoreToken.getMessageEccezioneInCache(response, keyCache, funzione));
  2218.                     throw (Exception) response.getException();
  2219.                 }else{
  2220.                     GestoreToken.loggerError(MESSAGE_ELEMENT_CACHE_NE_OGGETTO_NE_ECCEZIONE);
  2221.                 }
  2222.             }
  2223.             
  2224.             String idTransazione = (pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) ? PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext) : null;
  2225.             
  2226.             if(esitoRecuperoAttributi==null) {
  2227.             
  2228.                 org.openspcoop2.utils.Semaphore lockAttributeAuthority = getLockAttributeAuthority(aaName);
  2229.                 SemaphoreLock lock = lockAttributeAuthority.acquire("readAttributes", idTransazione);
  2230.                 try {
  2231.                     
  2232.                     response = 
  2233.                         (org.openspcoop2.utils.cache.CacheResponse) GestoreToken.cacheAttributeAuthority.get(keyCache);
  2234.                     if(response != null){
  2235.                         if(response.getObject()!=null){
  2236.                             GestoreToken.loggerDebug(GestoreToken.getMessageObjectInCache(response, keyCache, funzione));
  2237.                             esitoRecuperoAttributi = (EsitoRecuperoAttributi) response.getObject();
  2238.                             esitoRecuperoAttributi.setInCache(true);
  2239.                         }else if(response.getException()!=null){
  2240.                             GestoreToken.loggerDebug(GestoreToken.getMessageEccezioneInCache(response, keyCache, funzione));
  2241.                             throw (Exception) response.getException();
  2242.                         }else{
  2243.                             GestoreToken.loggerError(MESSAGE_ELEMENT_CACHE_NE_OGGETTO_NE_ECCEZIONE);
  2244.                         }
  2245.                     }
  2246.     
  2247.                     if(esitoRecuperoAttributi==null) {
  2248.                         // Effettuo la query
  2249.                         GestoreToken.loggerDebug(getPrefixOggettoConChiave(keyCache)+getSuffixEseguiOperazione(funzione));
  2250.                         
  2251.                         String request = null;
  2252.                         if(policyAttributeAuthority.isRequestDynamicPayloadJwt()) {
  2253.                             // ricostruisco per considerare le date
  2254.                             request = GestoreTokenAttributeAuthorityUtilities.buildDynamicAARequest(configurazionePdDManager, 
  2255.                                     protocolFactory, requestInfo, 
  2256.                                     policyAttributeAuthority, dynamicParameters, addIdAndDate);
  2257.                         }
  2258.                         else {
  2259.                             request = requestKeyCache;
  2260.                         }
  2261.                         
  2262.                         esitoRecuperoAttributi = GestoreTokenAttributeAuthorityUtilities.readAttributes(log, policyAttributeAuthority, 
  2263.                                 protocolFactory,
  2264.                                 dynamicParameters,
  2265.                                 request, portaDelegata, 
  2266.                                 pddContext, datiInvocazione.getBusta(),
  2267.                                 datiInvocazione.getIdModulo(), pa, pd,
  2268.                                 datiInvocazione.getState(),
  2269.                                 idDominio, idServizio,
  2270.                                 requestInfo);
  2271.                             
  2272.                         // Aggiungo la risposta in cache (se esiste una cache)  
  2273.                         // Sempre. Se la risposta non deve essere cachata l'implementazione può in alternativa:
  2274.                         // - impostare una eccezione di processamento (che setta automaticamente noCache a true)
  2275.                         // - impostare il noCache a true
  2276.                         if(esitoRecuperoAttributi!=null){ // altrimenti lo mettero' in cache al giro dopo.
  2277.                             esitoRecuperoAttributi.setInCache(false); // la prima volta che lo recupero sicuramente non era in cache
  2278.                             if(!esitoRecuperoAttributi.isNoCache()){
  2279.                                 GestoreToken.loggerInfo(getMessaggioAggiuntaOggettoInCache(keyCache));
  2280.                                 try{    
  2281.                                     org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  2282.                                     responseCache.setObject(esitoRecuperoAttributi);
  2283.                                     GestoreToken.cacheAttributeAuthority.put(keyCache,responseCache);
  2284.                                 }catch(UtilsException e){
  2285.                                     GestoreToken.loggerError(getMessaggioErroreInserimentoInCache(keyCache, e));
  2286.                                 }
  2287.                             }
  2288.                         }else{
  2289.                             throw new TokenException(getMessaggioErroreValoreEsitoNull( funzione));
  2290.                         }
  2291.                         
  2292.                         if(esitoRecuperoAttributi.isValido()) {
  2293.                             // ricontrollo tutte le date (l'ho appena preso, dovrebbero essere buone) 
  2294.                             GestoreTokenAttributeAuthorityUtilities.validazioneInformazioniAttributiRecuperati(esitoRecuperoAttributi, policyAttributeAuthority, 
  2295.                                     policyAttributeAuthority.isSaveErrorInCache(),
  2296.                                     dynamicParameters);
  2297.                         }
  2298.                     }
  2299.                     else {
  2300.                     
  2301.                         // l'ho preso in cache
  2302.                         
  2303.                         if(esitoRecuperoAttributi.isValido()) {
  2304.                             // controllo la data qua
  2305.                             GestoreTokenAttributeAuthorityUtilities.validazioneInformazioniAttributiRecuperati(esitoRecuperoAttributi, policyAttributeAuthority, 
  2306.                                     policyAttributeAuthority.isSaveErrorInCache(),
  2307.                                     dynamicParameters);
  2308.                             if(!esitoRecuperoAttributi.isValido() && !esitoRecuperoAttributi.isDateValide()) {
  2309.                                 // DEVO riavviare la negoziazione poichè è scaduto
  2310.                                 GestoreToken.cacheAttributeAuthority.remove(keyCache);
  2311.                                 riavviaNegoziazione = true;
  2312.                             }
  2313.                         }
  2314.                         
  2315.                     }
  2316.                     
  2317.                 } finally{
  2318.                     // fine synchronized
  2319.                     lockAttributeAuthority.release(lock, "readAttributes", idTransazione);
  2320.                 }
  2321.             }
  2322.             else {
  2323.                 
  2324.                 // l'ho preso in cache
  2325.                 
  2326.                 if(esitoRecuperoAttributi.isValido()) {
  2327.                     // controllo la data qua
  2328.                     GestoreTokenAttributeAuthorityUtilities.validazioneInformazioniAttributiRecuperati(esitoRecuperoAttributi, policyAttributeAuthority, 
  2329.                             policyAttributeAuthority.isSaveErrorInCache(),
  2330.                             dynamicParameters);
  2331.                     if(!esitoRecuperoAttributi.isValido() && !esitoRecuperoAttributi.isDateValide()) {
  2332.                         org.openspcoop2.utils.Semaphore lockAttributeAuthority = getLockAttributeAuthority(aaName);
  2333.                         SemaphoreLock lock = lockAttributeAuthority.acquire("removeAttributes", idTransazione);
  2334.                         try {
  2335.                             // DEVO riavviare la negoziazione poichè è scaduto
  2336.                             GestoreToken.cacheAttributeAuthority.remove(keyCache);
  2337.                             riavviaNegoziazione = true;
  2338.                         } finally{
  2339.                             // fine synchronized
  2340.                             lockAttributeAuthority.release(lock, "removeAttributes", idTransazione);
  2341.                         }
  2342.                     }
  2343.                 }
  2344.                 
  2345.             }
  2346.         }
  2347.         
  2348.         if(riavviaNegoziazione) {
  2349.             return readAttributes(log, datiInvocazione, pddContext, protocolFactory, portaDelegata,
  2350.                     idDominio, idServizio);
  2351.         }
  2352.         return esitoRecuperoAttributi;
  2353.     }
  2354.     
  2355.     public static InformazioniAttributi normalizeInformazioniAttributi(List<InformazioniAttributi> list, List<AttributeAuthority> aaList) throws Exception {
  2356.         
  2357.         /** int size = list.size();
  2358.         // Fix: deve basarsi sulle AA configurate e non su quelle da cui si e' ottenuto effettivamente una risposta, altrimenti poi le regole cambiano (prefisso AA presente o meno) */
  2359.         int size = aaList.size();
  2360.         if(size==1) {
  2361.             return list.get(0);
  2362.         }
  2363.         else {
  2364.             return new InformazioniAttributi(OpenSPCoop2Properties.getInstance().isGestioneAttributeAuthoritySaveSourceAttributeResponseInfo(), list.toArray(new InformazioniAttributi[1]));
  2365.         }
  2366.     }

  2368.     
  2369.     
  2370.     
  2371.     
  2372.     
  2373.     
  2374.     
  2375.     
  2376.     
  2377.     
  2378.     
  2379.     
  2380.     
  2381.     
  2382.     
  2383.     
  2384.     
  2385.     
  2386.     
  2387.     
  2388.     // ********* [GENERIC-TOKEN] ****************** */
  2389.     
  2390.     public static TokenCacheItem getTokenCacheItem(String keyCache, String funzione, Date now) throws TokenException {
  2391.         TokenCacheItem item = null;
  2392.         
  2393.         if(GestoreToken.cacheGestioneToken!=null){
  2394.             
  2395.             org.openspcoop2.utils.cache.CacheResponse response = 
  2396.                     (org.openspcoop2.utils.cache.CacheResponse) GestoreToken.cacheGestioneToken.get(keyCache);
  2397.             if(response != null){
  2398.                 if(response.getObject()!=null){
  2399.                     GestoreToken.loggerDebug(GestoreToken.getMessageObjectInCache(response, keyCache, funzione));
  2400.                     item = (TokenCacheItem) response.getObject();
  2401.                     item.setInCache(true);
  2402.                 }else if(response.getException()!=null){
  2403.                     Exception e = (Exception) response.getException();
  2404.                     throw new TokenException("Trovata eccezione '"+response.getException().getClass().getName()+"' in cache non prevista: "+e.getMessage(),e);
  2405.                 }else{
  2406.                     GestoreToken.loggerError(MESSAGE_ELEMENT_CACHE_NE_OGGETTO_NE_ECCEZIONE);
  2407.                 }
  2408.             }
  2409.             
  2410.             if(item!=null) {
  2411.                 item = checkTokenCacheItem(item, keyCache, now, true);
  2412.             }
  2413.         }
  2414.         
  2415.         return item;
  2416.     }
  2417.     private static TokenCacheItem checkTokenCacheItem(TokenCacheItem item, String keyCache, Date now, boolean debug) {
  2418.         boolean tokenExpired = false;
  2419.         if(item.getExp()!=null) {
  2420.             try{
  2421.                 tokenExpired = GestoreTokenValidazioneUtilities.isExpired(now, item.getExp());
  2422.             }catch(Exception e) {
  2423.                 GestoreToken.loggerError("Token presente in cache con chiave '"+keyCache+"', verifica scadenza '"+DateUtils.getSimpleDateFormatMs().format(item.getExp())+"' fallita: "+e.getMessage(),e);
  2424.             }
  2425.         }
  2426.         if(tokenExpired) {
  2427.             if(debug) {
  2428.                 GestoreToken.loggerDebug("Token presente in cache con chiave '"+keyCache+"' risulta scaduto in data '"+DateUtils.getSimpleDateFormatMs().format(item.getExp())+"'");
  2429.             }
  2430.             return null;
  2431.         }
  2432.         return item;
  2433.     }
  2434.     
  2435.     public static void putTokenCacheItem(TokenCacheItem item, String keyCache, String funzione, Date now) {
  2436.         
  2437.         if(GestoreToken.cacheGestioneToken!=null){
  2438.             
  2439.             // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  2440.             // Qua non va fatto come per gli altri casi, è nell'utilizzo del metodo getTokenCacheItem che lo si fa
  2441.             
  2442.             
  2443.             org.openspcoop2.utils.Semaphore lockNegoziazione = getLockGenericToken(funzione);
  2444.             SemaphoreLock lock = lockNegoziazione.acquireThrowRuntime("putTokenCacheItem", item.getIdTransazione());
  2445.             try {
  2446.                 
  2447.                 // per gestire concorrenza
  2448.                 org.openspcoop2.utils.cache.CacheResponse response = 
  2449.                     (org.openspcoop2.utils.cache.CacheResponse) GestoreToken.cacheGestioneToken.get(keyCache);
  2450.                 TokenCacheItem itemInCache = null;
  2451.                 if(response != null &&
  2452.                     response.getObject()!=null){
  2453.                     GestoreToken.loggerDebug(GestoreToken.getMessageObjectInCache(response, keyCache, funzione));
  2454.                     itemInCache = (TokenCacheItem) response.getObject();
  2455.                     itemInCache.setInCache(true);
  2456.                 }
  2457.                 if(itemInCache!=null) {
  2458.                     itemInCache = checkTokenCacheItem(itemInCache, keyCache, now, false);
  2459.                 }

  2461.                 if(itemInCache==null) {
  2462.                         
  2463.                     // Aggiungo la risposta in cache (se esiste una cache)  
  2464.                     // Sempre. Se la risposta non deve essere cachata l'implementazione può in alternativa:
  2465.                     // - impostare una eccezione di processamento (che setta automaticamente noCache a true)
  2466.                     // - impostare il noCache a true
  2467.                     item.setInCache(false); // la prima volta che lo recupero sicuramente non era in cache
  2468.                     GestoreToken.loggerInfo(getMessaggioAggiuntaOggettoInCache(keyCache));
  2469.                     try{    
  2470.                         org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  2471.                         responseCache.setObject(item);
  2472.                         GestoreToken.cacheGestioneToken.put(keyCache,responseCache);
  2473.                     }catch(UtilsException e){
  2474.                         GestoreToken.loggerError(getMessaggioErroreInserimentoInCache(keyCache, e));
  2475.                     }
  2476.                     
  2477.                 }
  2478.                 
  2479.             }finally {
  2480.                 // fine synchronized
  2481.                 lockNegoziazione.release(lock, "putTokenCacheItem", item.getIdTransazione());
  2482.             }

  2484.         }
  2485.     }
  2486. }
Created with JaCoCo 0.8.8.202204050719