NegoziazioneTokenProvider.java

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


package org.openspcoop2.pdd.core.token;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import org.apache.commons.lang.StringUtils;
import org.openspcoop2.core.config.constants.CostantiConfigurazione;
import org.openspcoop2.core.constants.CostantiConnettori;
import org.openspcoop2.core.mvc.properties.Item;
import org.openspcoop2.core.mvc.properties.constants.ItemType;
import org.openspcoop2.core.mvc.properties.provider.ExternalResources;
import org.openspcoop2.core.mvc.properties.provider.IProvider;
import org.openspcoop2.core.mvc.properties.provider.InputValidationUtils;
import org.openspcoop2.core.mvc.properties.provider.ProviderException;
import org.openspcoop2.core.mvc.properties.provider.ProviderInfo;
import org.openspcoop2.core.mvc.properties.provider.ProviderValidationException;
import org.openspcoop2.core.plugins.constants.TipoPlugin;
import org.openspcoop2.pdd.core.dynamic.DynamicHelperCostanti;
import org.openspcoop2.pdd.core.token.parser.Claims;
import org.openspcoop2.pdd.core.token.parser.ClaimsNegoziazione;
import org.openspcoop2.pdd.core.token.parser.INegoziazioneTokenParser;
import org.openspcoop2.security.message.constants.SecurityConstants;
import org.openspcoop2.security.message.utils.AbstractSecurityProvider;
import org.openspcoop2.utils.certificate.hsm.HSMUtils;
import org.openspcoop2.utils.properties.PropertiesUtilities;
import org.openspcoop2.utils.transport.http.HttpConstants;
import org.openspcoop2.utils.transport.http.HttpRequestMethod;
import org.openspcoop2.utils.transport.http.SSLUtilities;

/**     
 * GetTokenProvider
 *
 * @author Poli Andrea (poli@link.it)
 * @author $Author$
 * @version $Rev$, $Date$
 */
public class NegoziazioneTokenProvider implements IProvider {

	@Override
	public void validate(Map<String, Properties> mapProperties) throws ProviderException, ProviderValidationException {
		
		Properties pDefault = TokenUtilities.getDefaultProperties(mapProperties);
			
		boolean endpointSSL = TokenUtilities.isEnabled(pDefault, Costanti.POLICY_ENDPOINT_HTTPS_STATO);
		boolean ssl = TokenUtilities.isEnabled(pDefault, Costanti.POLICY_RETRIEVE_TOKEN_AUTH_SSL_STATO);
		
		if(endpointSSL || ssl) {
			validateEndpointSsl(mapProperties);
		}
		
		validateUrl(pDefault);
		
		String retMode = validateRetrieveMode(pDefault);
		
		boolean pdnd = TokenUtilities.isEnabled(pDefault, Costanti.POLICY_RETRIEVE_TOKEN_MODE_PDND);
			
					
		boolean basic = TokenUtilities.isEnabled(pDefault, Costanti.POLICY_RETRIEVE_TOKEN_AUTH_BASIC_STATO);
		if(basic) {
			validateBasicCredentials(pDefault);
		}
		
		boolean bearer = TokenUtilities.isEnabled(pDefault, Costanti.POLICY_RETRIEVE_TOKEN_AUTH_BEARER_STATO);
		if(bearer) {
			String token = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_AUTH_BEARER_TOKEN);
			InputValidationUtils.validateTextAreaInput(token, "Token Endpoint - Autenticazione Client - Token");
		}
		
		if(ssl) {
			validateSslCredentials(mapProperties);
		}
		
		boolean proxy = TokenUtilities.isEnabled(pDefault, Costanti.POLICY_ENDPOINT_PROXY_STATO);
		if(proxy) {
			validateProxy(mapProperties);
		}
		
		if(Costanti.ID_RETRIEVE_TOKEN_METHOD_RFC_7523_X509.equals(retMode) ||
				Costanti.ID_RETRIEVE_TOKEN_METHOD_RFC_7523_CLIENT_SECRET.equals(retMode)) {
			validateJWTSigned(pDefault, retMode, pdnd);
		}
		
		validateFormParameters(pDefault, pdnd);
		
		validateCustomFormParameters(pDefault, pdnd);
		
		validateHeaders(pDefault);
				
		if(Costanti.ID_RETRIEVE_TOKEN_METHOD_CUSTOM.equals(retMode)) {
			validateTokenParser(pDefault);
		}
		
		validateForward(pDefault);
		
	}
	private void validateEndpointSsl(Map<String, Properties> mapProperties) throws ProviderValidationException {
		Properties p = mapProperties.get(Costanti.POLICY_ENDPOINT_SSL_CONFIG);
		if(p==null || p.size()<=0) {
			throw new ProviderValidationException("Nonostante sia stato indicato un endpoint 'https', non è stata fornita una configurazione dei parametri ssl da utilizzare");
		}
		
		String trustAllCerts = p.getProperty(CostantiConnettori.CONNETTORE_HTTPS_TRUST_ALL_CERTS);
		boolean trustAll = false;
		if(trustAllCerts!=null && StringUtils.isNotEmpty(trustAllCerts)) {
			trustAll = Boolean.valueOf(trustAllCerts);
		}
		
		if(!trustAll) {
			String location = p.getProperty(CostantiConnettori.CONNETTORE_HTTPS_TRUST_STORE_LOCATION);
			InputValidationUtils.validateTextAreaInput(location, "Https - Autenticazione Server - File (TrustStore per l'autenticazione server)");
			
			String algo = p.getProperty(CostantiConnettori.CONNETTORE_HTTPS_TRUST_MANAGEMENT_ALGORITHM);
			if(algo==null || "".equals(algo)) {
				throw new ProviderValidationException("Indicare un algoritmo per l'autenticazione server");
			}
			if(algo.contains(" ")) {
				throw new ProviderValidationException("Non indicare spazi nell'algoritmo per l'autenticazione server");
			}
			
			String locationCRL = p.getProperty(CostantiConnettori.CONNETTORE_HTTPS_TRUST_STORE_CRLs);
			if(locationCRL!=null && !"".equals(locationCRL)) {
				InputValidationUtils.validateTextAreaInput(locationCRL, "Https - Autenticazione Server - CRL File(s)");
			}
		}
	}
	private void validateUrl(Properties pDefault) throws ProviderValidationException {
		String url = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_URL);
		InputValidationUtils.validateTextAreaInput(url, "Token Endpoint - URL");
		try{
			org.openspcoop2.utils.regexp.RegExpUtilities.validateUrl(url, true);
		}catch(Exception e){
			throw new ProviderValidationException("La URL fornita non è valida: "+e.getMessage());
		}	
	}
	private String validateRetrieveMode(Properties pDefault) throws ProviderValidationException {
		String retMode = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_MODE);
		if(Costanti.ID_RETRIEVE_TOKEN_METHOD_USERNAME_PASSWORD.equals(retMode)) {
			String username = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_USERNAME);
			if(username==null || "".equals(username)) {
				throw new ProviderValidationException("Non è stato fornito l'username");
			}
			if(username.contains(" ")) {
				throw new ProviderValidationException("Non indicare spazi nel'username");
			}
			String password = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_PASSWORD);
			if(password==null || "".equals(password)) {
				throw new ProviderValidationException("Non è stato fornita una password");
			}
			if(password.contains(" ")) {
				throw new ProviderValidationException("Non indicare spazi nella password");
			}
		}
		return retMode;
	}
	private void validateBasicCredentials(Properties pDefault) throws ProviderValidationException {
		String username = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_AUTH_BASIC_USERNAME);
		if(username==null || "".equals(username)) {
			throw new ProviderValidationException("Nonostante sia richiesta una autenticazione 'HttpBasic', non è stato fornito un 'Client ID' da utilizzare durante la connessione verso il servizio");
		}
		if(username.contains(" ")) {
			throw new ProviderValidationException("Non indicare spazi nel 'Client ID'");
		}
		String password = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_AUTH_BASIC_PASSWORD);
		if(password==null || "".equals(password)) {
			throw new ProviderValidationException("Nonostante sia richiesta una autenticazione 'HttpBasic', non è stato fornita un 'Client Secret' da utilizzare durante la connessione verso il servizio");
		}
		if(password.contains(" ")) {
			throw new ProviderValidationException("Non indicare spazi nel 'Client Secret'");
		}
	}
	private void validateSslCredentials(Map<String, Properties> mapProperties) throws ProviderValidationException {
		Properties p = mapProperties.get(Costanti.POLICY_ENDPOINT_SSL_CLIENT_CONFIG);
		if(p==null || p.size()<=0) {
			throw new ProviderValidationException("Nonostante sia richiesta una autenticazione 'Https', non sono stati forniti i parametri di connessione ssl client da utilizzare verso il servizio");
		}
		
		String location = p.getProperty(CostantiConnettori.CONNETTORE_HTTPS_KEY_STORE_LOCATION);
		if(location!=null && !"".equals(location)) {
			InputValidationUtils.validateTextAreaInput(location, "Https - Autenticazione Client - File (KeyStore per l'autenticazione client)");
		}
		
		String algo = p.getProperty(CostantiConnettori.CONNETTORE_HTTPS_KEY_MANAGEMENT_ALGORITHM);
		if(algo==null || "".equals(algo)) {
			throw new ProviderValidationException("Indicare un algoritmo per l'autenticazione client");
		}
		if(algo.contains(" ")) {
			throw new ProviderValidationException("Non indicare spazi nell'algoritmo per l'autenticazione client");
		}
	}
	private void validateProxy(Map<String, Properties> mapProperties) throws ProviderValidationException {
		Properties p = mapProperties.get(Costanti.POLICY_ENDPOINT_CONFIG);
		if(p==null || p.size()<=0) {
			throw new ProviderValidationException("Nonostante sia richiesta un proxy, non sono stati forniti i parametri di connessione");
		}
		
		String hostname = p.getProperty(CostantiConnettori.CONNETTORE_HTTP_PROXY_HOSTNAME);
		if(hostname==null || "".equals(hostname)) {
			throw new ProviderValidationException("Indicare un hostname per il Proxy");
		}
		if(hostname.contains(" ")) {
			throw new ProviderValidationException("Non indicare spazi nell'hostname del Proxy");
		}
		
		String username = p.getProperty(CostantiConnettori.CONNETTORE_HTTP_PROXY_USERNAME);
		if(username!=null && !"".equals(username) &&
			username.contains(" ")) {
			throw new ProviderValidationException("Non indicare spazi nell'username del Proxy");
		}
		
		String password = p.getProperty(CostantiConnettori.CONNETTORE_HTTP_PROXY_PASSWORD);
		if(password!=null && !"".equals(password) &&
			password.contains(" ")) {
			throw new ProviderValidationException("Non indicare spazi nella password del Proxy");
		}
	}
	private void validateJWTSigned(Properties pDefault, String retMode, boolean pdnd) throws ProviderValidationException {
		if(Costanti.ID_RETRIEVE_TOKEN_METHOD_RFC_7523_X509.equals(retMode)) {
			validateJWTSignedx509(pDefault);
		}
		else {
			/**
			// Costanti.ID_RETRIEVE_TOKEN_METHOD_RFC_7523_CLIENT_SECRET.equals(retMode)) {
		
			// Una password può contenere gli spazi, i controlli di inizio e fine vengono gia' fatti dal framework
			
//			String clientSecret = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_JWT_CLIENT_SECRET);
//			if(clientSecret!=null && clientSecret.contains(" ")) {
//				throw new ProviderValidationException("Non indicare spazi nel campo 'Client Secret'");
//			}
			*/
		}
		
		// NOTA: i controlli seguenti di inizio e fine, vengono fatti gia' in automatico dal framework
		
		validateJWTSignedHeader(pDefault);
							
		validateJWTSignedPayload(pDefault, pdnd);
		
	}
	private void validateJWTSignedx509(Properties pDefault) throws ProviderValidationException {
		validateJWTSignedx509Keystore(pDefault);
		validateJWTSignedx509Key(pDefault);
	}
	private void validateJWTSignedx509Keystore(Properties pDefault) throws ProviderValidationException {
		String file = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_JWT_SIGN_KEYSTORE_FILE);
		InputValidationUtils.validateTextAreaInput(file, "Token Endpoint - JWT KeyStore - File");
		
		String fileChiavePubblica = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_JWT_SIGN_KEYSTORE_FILE_PUBLIC_KEY);
		if(fileChiavePubblica!=null && StringUtils.isNotEmpty(fileChiavePubblica)) {
			InputValidationUtils.validateTextAreaInput(file, "Token Endpoint - JWT KeyStore - Chiave Pubblica");
		}
		
		// NOTA: i controlli seguenti di inizio e fine, vengono fatti gia' in automatico dal framework
		String p = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_JWT_SIGN_KEYSTORE_PASSWORD);
		if(p!=null) {
			if(p.startsWith(" ")) {
				throw new ProviderValidationException("Il valore indicato nel campo 'JWT KeyStore - Password', non deve iniziare con uno spazio");
			}
			if(p.endsWith(" ")) {
				throw new ProviderValidationException("Il valore indicato nel campo 'JWT KeyStore - Password', non deve terminare con uno spazio");
			}
		}
	}
	private void validateJWTSignedx509Key(Properties pDefault) throws ProviderValidationException {
		
		// NOTA: i controlli seguenti di inizio e fine, vengono fatti gia' in automatico dal framework
		String p = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_JWT_SIGN_KEY_ALIAS);
		if(p!=null) {
			if(p.startsWith(" ")) {
				throw new ProviderValidationException("Il valore indicato nel campo 'JWT KeyStore - Alias Chiave Privata', non deve iniziare con uno spazio");
			}
			if(p.endsWith(" ")) {
				throw new ProviderValidationException("Il valore indicato nel campo 'JWT KeyStore - Alias Chiave Privata', non deve terminare con uno spazio");
			}
		}
		
		p = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_JWT_SIGN_KEY_PASSWORD);
		if(p!=null) {
			if(p.startsWith(" ")) {
				throw new ProviderValidationException("Il valore indicato nel campo 'JWT KeyStore - Password Chiave Privata', non deve iniziare con uno spazio");
			}
			if(p.endsWith(" ")) {
				throw new ProviderValidationException("Il valore indicato nel campo 'JWT KeyStore - Password Chiave Privata', non deve terminare con uno spazio");
			}
		}
	}
	private void validateJWTSignedHeader(Properties pDefault) throws ProviderValidationException {
		String kidMode = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_JWT_SIGN_INCLUDE_KEY_ID);
		if(Costanti.POLICY_RETRIEVE_TOKEN_JWT_SIGN_INCLUDE_KEY_ID_MODE_CUSTOM.equals(kidMode)) {
			String kidValue = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_JWT_SIGN_INCLUDE_KEY_ID_VALUE);
			if(kidValue!=null) {
				if(kidValue.startsWith(" ")) {
					throw new ProviderValidationException("Il valore indicato nel campo 'JWT Header - Key Id (kid)', non deve iniziare con uno spazio");
				}
				if(kidValue.endsWith(" ")) {
					throw new ProviderValidationException("Il valore indicato nel campo 'JWT Header - Key Id (kid)', non deve terminare con uno spazio");
				}
			}
		}
		
		String type = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_JWT_SIGN_JOSE_TYPE);
		if(type!=null && type.contains(" ")) {
			throw new ProviderValidationException("Non indicare spazi nel campo 'JWT Header - Type (typ)'");
		}
		
		String x5u = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_JWT_SIGN_INCLUDE_X509_URL);
		if(x5u!=null && !"".equals(x5u)) {
			InputValidationUtils.validateTextAreaInput(x5u, "Token Endpoint - JWT Header - URL");
		}
	}
	private void validateJWTSignedPayload(Properties pDefault, boolean pdnd) throws ProviderValidationException {
		String clientId = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_JWT_CLIENT_ID);
		if(clientId!=null && clientId.contains(" ")) {
			throw new ProviderValidationException("Non indicare spazi nel campo 'JWT Payload - Client ID'");
		}
		
		String audience = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_JWT_AUDIENCE);
		if(audience!=null && audience.contains(" ")) {
			throw new ProviderValidationException("Non indicare spazi nel campo 'JWT Payload - Audience'");
		}
		
		String issuer = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_JWT_ISSUER);
		if(issuer!=null && issuer.contains(" ")) {
			throw new ProviderValidationException("Non indicare spazi nel campo 'JWT Payload - Issuer'");
		}
		
		String subject = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_JWT_SUBJECT);
		if(subject!=null && subject.contains(" ")) {
			throw new ProviderValidationException("Non indicare spazi nel campo 'JWT Payload - Subject'");
		}
		
		String jti = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_JWT_IDENTIFIER);
		if(jti!=null && jti.contains(" ")) {
			throw new ProviderValidationException("Non indicare spazi nel campo 'JWT Payload - Identifier'");
		}
		
		if(pdnd) {
			validateJWTSignedPayloadPDND(pDefault);			
		}
		
		validateJWTSignedClaims(pDefault, pdnd);
	}
	private void validateJWTSignedPayloadPDND(Properties pDefault) throws ProviderValidationException {
		String purposeId = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_JWT_PURPOSE_ID);
		if(purposeId!=null && purposeId.contains(" ")) {
			throw new ProviderValidationException("Non indicare spazi nel campo 'JWT Payload - Purpose ID'");
		}
		
		String session = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_JWT_SESSION_INFO);
		if(session!=null && !"".equals(session)) {
			Properties convertTextToProperties = PropertiesUtilities.convertTextToProperties(session);
			List<String> deny = new ArrayList<>();
			TokenUtilities.checkClaims("claim", convertTextToProperties, "Informazioni Sessione", deny, false);
		}
	}
	private void validateJWTSignedClaims(Properties pDefault, boolean pdnd) throws ProviderValidationException {
		String claims = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_JWT_CLAIMS);
		if(claims!=null && !"".equals(claims)) {
			Properties convertTextToProperties = PropertiesUtilities.convertTextToProperties(claims);
			List<String> deny = new ArrayList<>();
			deny.add(Claims.OIDC_ID_TOKEN_ISSUER);
			deny.add(Claims.OIDC_ID_TOKEN_SUBJECT);
			deny.add(Claims.INTROSPECTION_RESPONSE_RFC_7662_CLIENT_ID);
			deny.add(Claims.OIDC_ID_TOKEN_AUDIENCE);
			deny.add(Claims.JSON_WEB_TOKEN_RFC_7519_ISSUED_AT);
			deny.add(Claims.JSON_WEB_TOKEN_RFC_7519_NOT_TO_BE_USED_BEFORE);
			deny.add(Claims.JSON_WEB_TOKEN_RFC_7519_EXPIRED);
			deny.add(Claims.JSON_WEB_TOKEN_RFC_7519_JWT_ID);
			if(pdnd) {
				deny.add(Costanti.PDND_PURPOSE_ID);
				deny.add(Costanti.PDND_SESSION_INFO);
			}
			TokenUtilities.checkClaims("claim", convertTextToProperties, "Claims", deny, false);
		}
	}
	private void validateFormParameters(Properties pDefault, boolean pdnd) throws ProviderValidationException {
		String scopes = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_SCOPES);
		if(scopes!=null && !"".equals(scopes) &&
			scopes.contains(" ")) {
			throw new ProviderValidationException("Non indicare spazi tra gli scope forniti");
		}
		
		String audience = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_AUDIENCE);
		if(audience!=null && !"".equals(audience) &&
			audience.contains(" ")) {
			throw new ProviderValidationException("Non indicare spazi nel valore dell'audience");
		}
		
		if(pdnd) {
			String clientId = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_FORM_CLIENT_ID);
			if(clientId!=null && clientId.contains(" ")) {
				throw new ProviderValidationException("Non indicare spazi nel campo 'Client ID'");
			}
			
			String resource = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_FORM_RESOURCE);
			if(resource!=null && resource.contains(" ")) {
				throw new ProviderValidationException("Non indicare spazi nel campo 'Resource'");
			}
		}
	}
	private void validateCustomFormParameters(Properties pDefault, boolean pdnd) throws ProviderValidationException {
		String parameters = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_FORM_PARAMETERS);
		if(parameters!=null && !"".equals(parameters)) {
			Properties convertTextToProperties = PropertiesUtilities.convertTextToProperties(parameters);
			List<String> deny = new ArrayList<>();
			deny.add(ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_GRANT_TYPE);
			deny.add(ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_CLIENT_ASSERTION_TYPE);
			deny.add(ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_CLIENT_ASSERTION);
			deny.add(ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_SCOPE);
			deny.add(ClaimsNegoziazione.OAUTH2_RFC_6749_REQUEST_AUDIENCE);
			if(pdnd) {
				deny.add(Costanti.PDND_OAUTH2_RFC_6749_REQUEST_CLIENT_ID);
			}
			TokenUtilities.checkClaims("parametro", convertTextToProperties, "Parametri", deny, false);
		}	
	}
	private void validateHeaders(Properties pDefault) throws ProviderValidationException {
		String headers = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_HTTP_HEADERS);
		if(headers!=null && !"".equals(headers)) {
			Properties convertTextToProperties = PropertiesUtilities.convertTextToProperties(headers);
			List<String> deny = new ArrayList<>();
			deny.add(HttpConstants.AUTHORIZATION);
			deny.add(HttpConstants.CONTENT_TYPE);
			TokenUtilities.checkClaims("header http", convertTextToProperties, "Header HTTP", deny, false);
		}
	}
	private void validateTokenParser(Properties pDefault) throws ProviderValidationException {
		String parser = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_PARSER_TYPE_CUSTOM);
		if(parser!=null && Costanti.POLICY_RETRIEVE_TOKEN_PARSER_TYPE_CUSTOM_CYSTOM.equals(parser)) {
			String pluginType = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_PARSER_PLUGIN_TYPE);
			validateTokenParser(pDefault, pluginType);
		}
	}
	private void validateTokenParser(Properties pDefault, String pluginType) throws ProviderValidationException {
		if(pluginType!=null && StringUtils.isNotEmpty(pluginType) && CostantiConfigurazione.POLICY_ID_NON_DEFINITA.equals(pluginType)) {
			String className = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_PARSER_CLASS_NAME);
			if(CostantiConfigurazione.POLICY_ID_NON_DEFINITA.equals(className)) {
				throw new ProviderValidationException("Deve essere selezionato un plugin per il 'Formato Risposta'");	
			}
			else {
				if(className==null || "".equals(className)) {
					throw new ProviderValidationException("Non è stata fornita la classe del parser dei claims della risposta");
				}
				if(className.contains(" ")) {
					throw new ProviderValidationException("Non indicare spazi nella classe del parser dei claims della risposta");
				}
			}
		}
	}
	private void validateForward(Properties pDefault) throws ProviderValidationException {
		String mode = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_FORWARD_MODE);
		if(mode==null) {
			throw new ProviderValidationException("Nessuna modalità di forward indicata");
		}
		if(!Costanti.POLICY_RETRIEVE_TOKEN_FORWARD_MODE_RFC6750_HEADER.equals(mode) &&
				!Costanti.POLICY_RETRIEVE_TOKEN_FORWARD_MODE_RFC6750_URL.equals(mode) &&
				!Costanti.POLICY_RETRIEVE_TOKEN_FORWARD_MODE_CUSTOM_HEADER.equals(mode) &&
				!Costanti.POLICY_RETRIEVE_TOKEN_FORWARD_MODE_CUSTOM_URL.equals(mode)
				) {
			throw new ProviderValidationException("La modalità di forward indicata '"+mode+"' non è supportata");	
		}
		if(Costanti.POLICY_RETRIEVE_TOKEN_FORWARD_MODE_CUSTOM_HEADER.equals(mode)) {
			String hdr = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_FORWARD_MODE_CUSTOM_HEADER_NAME);
			if(hdr==null || "".equals(hdr)) {
				throw new ProviderValidationException("La modalità di forward indicata prevede l'indicazione del nome di un header http");
			}
			if(hdr.contains(" ")) {
				throw new ProviderValidationException("Non indicare spazi nel nome dell'header HTTP indicato per la modalità di forward");
			}
		}
		else if(Costanti.POLICY_RETRIEVE_TOKEN_FORWARD_MODE_CUSTOM_URL.equals(mode)) {
			String urlP = pDefault.getProperty(Costanti.POLICY_RETRIEVE_TOKEN_FORWARD_MODE_CUSTOM_URL_PARAMETER_NAME);
			if(urlP==null || "".equals(urlP)) {
				throw new ProviderValidationException("La modalità di forward indicata prevede l'indicazione del nome di una proprietà della url");
			}
			if(urlP.contains(" ")) {
				throw new ProviderValidationException("Non indicare spazi nel nome della proprietà della url indicata per la modalità di forward");
			}
		}
	}


	@Override
	public List<String> getValues(String id) throws ProviderException {
		return this.getValues(id, null);
	}
	@Override
	public List<String> getValues(String id, ExternalResources externalResources) throws ProviderException{
		List<String> values = null;
		if(Costanti.ID_RETRIEVE_TOKEN_METHOD.equals(id)) {
			List<String> methodsList = new ArrayList<>();
			methodsList.add(Costanti.ID_RETRIEVE_TOKEN_METHOD_CLIENT_CREDENTIAL);
			methodsList.add(Costanti.ID_RETRIEVE_TOKEN_METHOD_USERNAME_PASSWORD);
			methodsList.add(Costanti.ID_RETRIEVE_TOKEN_METHOD_RFC_7523_X509);
			methodsList.add(Costanti.ID_RETRIEVE_TOKEN_METHOD_RFC_7523_CLIENT_SECRET);
			methodsList.add(Costanti.ID_RETRIEVE_TOKEN_METHOD_CUSTOM);
			return methodsList;
		}
		else if(Costanti.ID_TIPOLOGIA_HTTPS.equals(id)) {
			List<String> tipologie = null;
			try{
				tipologie = SSLUtilities.getSSLSupportedProtocols();
			}catch(Exception e){
				tipologie = SSLUtilities.getAllSslProtocol();
			}
			return tipologie;
		}
		else if(Costanti.ID_RETRIEVE_TOKEN_JWT_SYMMETRIC_SIGN_ALGORITHM.equals(id) ||
				Costanti.ID_RETRIEVE_TOKEN_JWT_ASYMMETRIC_SIGN_ALGORITHM.equals(id)) {
			return getValuesSignatureAlgorithm(id);
		}
		else if(Costanti.ID_NEGOZIAZIONE_JWT_KEYSTORE_TYPE.equals(id) || 
				Costanti.ID_HTTPS_TRUSTSTORE_TYPE.equals(id) ||
				Costanti.ID_HTTPS_KEYSTORE_TYPE.equals(id)) {
			return getStoreType(id,true);
		}
		else if(Costanti.ID_RETRIEVE_HTTP_METHOD.equals(id)) {
			List<String> methodsList = new ArrayList<>();
			HttpRequestMethod [] methods = HttpRequestMethod.values();
			for (int i = 0; i < methods.length; i++) {
				methodsList.add(methods[i].name());
			}
			return methodsList;
		}
		else if(Costanti.ID_NEGOZIAZIONE_CUSTOM_PARSER_PLUGIN_CHOICE.equals(id)) {
			return TokenUtilities.getTokenPluginValues(externalResources, TipoPlugin.TOKEN_NEGOZIAZIONE);
		}
		return values;
	}
	private List<String> getValuesSignatureAlgorithm(String id) {
		List<String> l = new ArrayList<>();
		org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm [] tmp = org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm.values();
		for (int i = 0; i < tmp.length; i++) {
			if(org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm.NONE.equals(tmp[i])) {
				continue;
			}
			if(Costanti.ID_RETRIEVE_TOKEN_JWT_SYMMETRIC_SIGN_ALGORITHM.equals(id)) {
				if(tmp[i].name().toLowerCase().startsWith("hs")) {
					l.add(tmp[i].name());
				}
			}
			else {
				if(!tmp[i].name().toLowerCase().startsWith("hs")) {
					l.add(tmp[i].name());
				}
			}
		}
		return l;
	}

	@Override
	public List<String> getLabels(String id) throws ProviderException {
		return this.getLabels(id, null);
	}
	@Override
	public List<String> getLabels(String id, ExternalResources externalResources) throws ProviderException{
		if(Costanti.ID_RETRIEVE_TOKEN_METHOD.equals(id)) {
			List<String> methodsList = new ArrayList<>();
			methodsList.add(Costanti.ID_RETRIEVE_TOKEN_METHOD_CLIENT_CREDENTIAL_LABEL);
			methodsList.add(Costanti.ID_RETRIEVE_TOKEN_METHOD_USERNAME_PASSWORD_LABEL);
			methodsList.add(Costanti.ID_RETRIEVE_TOKEN_METHOD_RFC_7523_X509_LABEL);
			methodsList.add(Costanti.ID_RETRIEVE_TOKEN_METHOD_RFC_7523_CLIENT_SECRET_LABEL);
			methodsList.add(Costanti.ID_RETRIEVE_TOKEN_METHOD_CUSTOM_LABEL);
			return methodsList;
		}
		else if(Costanti.ID_RETRIEVE_TOKEN_JWT_SYMMETRIC_SIGN_ALGORITHM.equals(id) ||
				Costanti.ID_RETRIEVE_TOKEN_JWT_ASYMMETRIC_SIGN_ALGORITHM.equals(id)) {
			return getLabelsSignatureAlgorithm(id);
		}
		else if(Costanti.ID_NEGOZIAZIONE_JWT_KEYSTORE_TYPE.equals(id) || 
				Costanti.ID_HTTPS_TRUSTSTORE_TYPE.equals(id) ||
				Costanti.ID_HTTPS_KEYSTORE_TYPE.equals(id)) {
			return getStoreType(id,false);
		}
		else if(Costanti.ID_NEGOZIAZIONE_CUSTOM_PARSER_PLUGIN_CHOICE.equals(id)) {
			return TokenUtilities.getTokenPluginLabels(externalResources, TipoPlugin.TOKEN_NEGOZIAZIONE);
		}
		return this.getValues(id); // torno uguale ai valori negli altri casi
	}
	private List<String> getLabelsSignatureAlgorithm(String id) throws ProviderException{
		List<String> l = this.getValues(id);
		List<String> labels = new ArrayList<>();
		for (String value : l) {
			if(value.contains("_")) {
				String t = "" + value;
				while(t.contains("_")) {
					t = t.replace("_", "-");
				}
				labels.add(t);
			}
			else {
				labels.add(value);
			}
		}
		return labels;
	}
	
	private static boolean secret = false;
	public static boolean isSecret() {
		return secret;
	}
	public static void setSecret(boolean secret) {
		NegoziazioneTokenProvider.secret = secret;
	}

	private List<String> getStoreType(String id,boolean value){
		boolean trustStore = true;
		List<String> l = new ArrayList<>();
		l.add(value ? SecurityConstants.KEYSTORE_TYPE_JKS_VALUE : SecurityConstants.KEYSTORE_TYPE_JKS_LABEL);
		l.add(value ? SecurityConstants.KEYSTORE_TYPE_PKCS12_VALUE : SecurityConstants.KEYSTORE_TYPE_PKCS12_LABEL);
		if(Costanti.ID_NEGOZIAZIONE_JWT_KEYSTORE_TYPE.equals(id)) {
			l.add(value ? SecurityConstants.KEYSTORE_TYPE_JWK_VALUE: SecurityConstants.KEYSTORE_TYPE_JWK_LABEL);
			l.add(value ? SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE: SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_LABEL);
		}
/**		if(Costanti.UNKNOWN.equals(id)) {
//			l.add(value ? SecurityConstants.KEYSTORE_TYPE_JCEKS_VALUE : SecurityConstants.KEYSTORE_TYPE_JCEKS_LABEL);
//			secret = true;
//		}
		**/
		if(Costanti.ID_NEGOZIAZIONE_JWT_KEYSTORE_TYPE.equals(id)) {
			l.add(value ? Costanti.KEYSTORE_TYPE_APPLICATIVO_MODI_VALUE: Costanti.KEYSTORE_TYPE_APPLICATIVO_MODI_LABEL);
			l.add(value ? Costanti.KEYSTORE_TYPE_FRUIZIONE_MODI_VALUE: Costanti.KEYSTORE_TYPE_FRUIZIONE_MODI_LABEL);
		}
		
		if(Costanti.ID_NEGOZIAZIONE_JWT_KEYSTORE_TYPE.equals(id) ||
				Costanti.ID_HTTPS_KEYSTORE_TYPE.equals(id)) {
			trustStore = false;
		}
		HSMUtils.fillTipologieKeystore(trustStore, false, l);
		
		if(secret) {
			// aggiunto info mancanti come secret
			addStoreTypeSecret(l);
		}
		return l;
	}
	private void addStoreTypeSecret(List<String> l) {
		List<String> lSecret = new ArrayList<>();
		HSMUtils.fillTipologieKeystore(false, true, lSecret);
		if(!lSecret.isEmpty()) {
			for (String type : lSecret) {
				if(!l.contains(type)) {
					l.add(type);
				}
			}
		}
	}
	

	@Override
	public String getDefault(String id) throws ProviderException {
		return getDefault(id, null);
	}
	@Override
	public String getDefault(String id, ExternalResources externalResources) throws ProviderException {
		if(Costanti.ID_RETRIEVE_TOKEN_METHOD.equals(id)) {
			return Costanti.ID_RETRIEVE_TOKEN_METHOD_CLIENT_CREDENTIAL;
		}
		else if(Costanti.ID_TIPOLOGIA_HTTPS.equals(id)) {
			return SSLUtilities.getSafeDefaultProtocol();
		}
		else if(Costanti.ID_RETRIEVE_TOKEN_JWT_EXPIRED_TTL_SECONDS.equals(id)) {
			return Costanti.POLICY_RETRIEVE_TOKEN_JWT_EXPIRED_TTL_SECONDS_DEFAULT_VALUE;
		}
		else if(Costanti.ID_RETRIEVE_TOKEN_JWT_SYMMETRIC_SIGN_ALGORITHM.equals(id)) {
			return org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm.HS256.name();
		}
		else if(Costanti.ID_RETRIEVE_TOKEN_JWT_ASYMMETRIC_SIGN_ALGORITHM.equals(id)) {
			return org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm.RS256.name();
		}
		else if(Costanti.ID_RETRIEVE_HTTP_METHOD.equals(id)) {
			return HttpRequestMethod.GET.name();
		}
		return null;
	}

	private boolean isProviderInfoStandard(String id) {
		return 
			Costanti.ID_RETRIEVE_ENDPOINT_URL.equals(id) ||
			Costanti.ID_RETRIEVE_AUTENTICAZIONE_USERNAME.equals(id) ||
			Costanti.ID_RETRIEVE_AUTENTICAZIONE_PASSWORD.equals(id) ||
			Costanti.ID_RETRIEVE_CLIENT_ID.equals(id) ||
			Costanti.ID_RETRIEVE_CLIENT_ID_CUSTOM.equals(id) ||
			Costanti.ID_RETRIEVE_CLIENT_SECRET.equals(id) ||
			Costanti.ID_RETRIEVE_CLIENT_SECRET_CUSTOM.equals(id) ||
			Costanti.ID_RETRIEVE_BEARER_TOKEN.equals(id) ||
			Costanti.ID_RETRIEVE_JWT_X5U.equals(id) ||
			Costanti.ID_RETRIEVE_JWT_KID_VALUE.equals(id) ||
			Costanti.ID_RETRIEVE_JWT_PURPOSE_ID.equals(id) ||
			Costanti.ID_RETRIEVE_SCOPE.equals(id) ||
			Costanti.ID_RETRIEVE_AUDIENCE.equals(id) ||
			Costanti.ID_RETRIEVE_FORM_PARAMETERS.equals(id) ||
			Costanti.ID_RETRIEVE_HTTP_CONTENT_TYPE.equals(id) ||
			Costanti.ID_RETRIEVE_HTTP_HEADERS.equals(id) ||
			Costanti.ID_RETRIEVE_HTTP_TEMPLATE_PAYLOAD.equals(id);
	}
	@Override
	public ProviderInfo getProviderInfo(String id) throws ProviderException{
		if(isProviderInfoStandard(id)) {
			ProviderInfo pInfo = new ProviderInfo();
			pInfo.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_INFO_TRASPORTO);
			pInfo.setListBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_NEGOZIAZIONE_TOKEN_INFO_VALORI);
			return pInfo;
		}
		else if(Costanti.ID_RETRIEVE_JWT_ISSUER.equals(id) ||
				Costanti.ID_RETRIEVE_JWT_ISSUER_APPLICATIVO_MODI_CUSTOM.equals(id)
				) {
			ProviderInfo pInfo = new ProviderInfo();
			pInfo.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_NEGOZIAZIONE_ISSUER);
			pInfo.setListBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_NEGOZIAZIONE_TOKEN_INFO_VALORI_CON_OPZIONE_VALORE_NON_DEFINITO);
			return pInfo;
		}
		else if(Costanti.ID_RETRIEVE_JWT_SUBJECT.equals(id) ||
				Costanti.ID_RETRIEVE_JWT_SUBJECT_APPLICATIVO_MODI_CUSTOM.equals(id)
				) {
			ProviderInfo pInfo = new ProviderInfo();
			pInfo.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_NEGOZIAZIONE_SUBJECT);
			pInfo.setListBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_NEGOZIAZIONE_TOKEN_INFO_VALORI_CON_OPZIONE_VALORE_NON_DEFINITO);
			return pInfo;
		}
		else if(Costanti.ID_RETRIEVE_JWT_IDENTIFIER.equals(id)
				) {
			ProviderInfo pInfo = new ProviderInfo();
			pInfo.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_NEGOZIAZIONE_IDENTIFIER);
			pInfo.setListBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_NEGOZIAZIONE_TOKEN_INFO_VALORI_CON_OPZIONE_VALORE_NON_DEFINITO);
			return pInfo;
		}
		else if(Costanti.ID_RETRIEVE_JWT_CLIENT_ID.equals(id) ||
				Costanti.ID_RETRIEVE_JWT_CLIENT_ID_APPLICATIVO_MODI_CUSTOM.equals(id) ||
				Costanti.ID_RETRIEVE_JWT_AUDIENCE.equals(id) ||
				Costanti.ID_RETRIEVE_FORM_RESOURCE.equals(id)
				) {
			ProviderInfo pInfo = new ProviderInfo();
			pInfo.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_INFO_TRASPORTO);
			pInfo.setListBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_NEGOZIAZIONE_TOKEN_INFO_VALORI_CON_OPZIONE_VALORE_NON_DEFINITO);
			return pInfo;
		}
		else if(Costanti.ID_RETRIEVE_FORM_CLIENT_ID.equals(id) ||
				Costanti.ID_RETRIEVE_FORM_CLIENT_ID_APPLICATIVO_MODI_CUSTOM.equals(id)
				) {
			ProviderInfo pInfo = new ProviderInfo();
			pInfo.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_NEGOZIAZIONE_FORM_PARAMETRO_CLIENT_ID);
			pInfo.setListBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_NEGOZIAZIONE_TOKEN_INFO_VALORI_CON_OPZIONE_VALORE_NON_DEFINITO);
			return pInfo;
		}
		else if(Costanti.ID_RETRIEVE_JWT_CLAIMS.equals(id) ||
				Costanti.ID_RETRIEVE_JWT_SESSION_INFO.equals(id)
				) {
			ProviderInfo pInfo = new ProviderInfo();
			pInfo.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_CLAIMS);
			pInfo.setListBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_NEGOZIAZIONE_TOKEN_INFO_VALORI);
			return pInfo;
		}
		else if(Costanti.ID_RETRIEVE_HTTP_FREEMARKER_PAYLOAD.equals(id)) {
			ProviderInfo pInfo = new ProviderInfo();
			pInfo.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_INFO_OBJECT_TEMPLATE_FREEMARKER);
			pInfo.setListBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_NEGOZIAZIONE_TOKEN_INFO_OBJECT_VALORI);
			return pInfo;
		}
		else if(Costanti.ID_RETRIEVE_HTTP_VELOCITY_PAYLOAD.equals(id)) {
			ProviderInfo pInfo = new ProviderInfo();
			pInfo.setHeaderBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_INFO_OBJECT_TEMPLATE_VELOCITY);
			pInfo.setListBody(DynamicHelperCostanti.LABEL_CONFIGURAZIONE_NEGOZIAZIONE_TOKEN_INFO_OBJECT_VALORI);
			return pInfo;
		}
		else if(Costanti.ID_NEGOZIAZIONE_CUSTOM_PARSER_PLUGIN_CLASSNAME.equals(id)) {
			return getProviderInfoCustomParserPluginClassname();
		}
		
		return null;
	}
	private ProviderInfo getProviderInfoCustomParserPluginClassname() {
		ProviderInfo pInfo = new ProviderInfo();
		pInfo.setHeaderBody(DynamicHelperCostanti.PLUGIN_CLASSNAME_INFO_SINGOLA);
		pInfo.setListBody(new ArrayList<>());
		pInfo.getListBody().add(INegoziazioneTokenParser.class.getName());
		return pInfo;
	}
	
	@Override
	public String dynamicUpdate(List<?> items, Map<String, String> mapNameValue, Item item, String actualValue) {
		return dynamicUpdate(items, mapNameValue, item, actualValue, null);
	}
	@Override
	public String dynamicUpdate(List<?> items, Map<String, String> mapNameValue, Item item, String actualValue, ExternalResources externalResources) {
	
		if(Costanti.ID_NEGOZIAZIONE_JWT_KEYSTORE_FILE.equals(item.getName()) ||
				Costanti.ID_NEGOZIAZIONE_JWT_KEYSTORE_FILE_PRIVATE_KEY.equals(item.getName()) ||
				Costanti.ID_NEGOZIAZIONE_JWT_KEYSTORE_FILE_PUBLIC_KEY.equals(item.getName()) ||
				Costanti.ID_HTTPS_TRUSTSTORE_FILE.equals(item.getName()) ||
				Costanti.ID_HTTPS_KEYSTORE_FILE.equals(item.getName())) {
			return dynamicUpdateStoreFile(items, mapNameValue, item, actualValue);
		}
		else if(Costanti.ID_NEGOZIAZIONE_JWT_KEYSTORE_PASSWORD.equals(item.getName()) ||
				Costanti.ID_HTTPS_TRUSTSTORE_PASSWORD.equals(item.getName()) ||
				Costanti.ID_HTTPS_KEYSTORE_PASSWORD.equals(item.getName())) {
			return dynamicUpdateStorePassword(items, mapNameValue, item, actualValue);
		}
		else if(Costanti.ID_NEGOZIAZIONE_JWT_KEYSTORE_PASSWORD_PRIVATE_KEY.equals(item.getName()) ||
				Costanti.ID_NEGOZIAZIONE_JWT_KEYSTORE_PASSWORD_PRIVATE_KEY_OPZIONALE.equals(item.getName()) ||
				Costanti.ID_HTTPS_KEYSTORE_PASSWORD_PRIVATE_KEY.equals(item.getName()) ) {
			return dynamicUpdateStoreKeyPassword(items, mapNameValue, item, actualValue);	
		}
		else if(Costanti.ID_NEGOZIAZIONE_JWT_KEYSTORE_ALIAS_PRIVATE_KEY.equals(item.getName()) ) {
			
			String type = Costanti.ID_NEGOZIAZIONE_JWT_KEYSTORE_TYPE;
			
			String typeValue = AbstractSecurityProvider.readValue(type, items, mapNameValue);
			if(Costanti.KEYSTORE_TYPE_APPLICATIVO_MODI_VALUE.equals(typeValue) || Costanti.KEYSTORE_TYPE_FRUIZIONE_MODI_VALUE.equals(typeValue)) {
				item.setValue("-");
				item.setType(ItemType.HIDDEN);
				return item.getValue();
			}
			else {
				item.setType(ItemType.TEXT);
			}
			
		}		
		else if(Costanti.ID_NEGOZIAZIONE_CUSTOM_PARSER_PLUGIN_CHOICE.equals(item.getName())) {
			return TokenUtilities.dynamicUpdateTokenPluginChoice(externalResources, TipoPlugin.TOKEN_NEGOZIAZIONE, item, actualValue);
		}
		else if(Costanti.ID_NEGOZIAZIONE_CUSTOM_PARSER_PLUGIN_CLASSNAME.equals(item.getName())) {
			return TokenUtilities.dynamicUpdateTokenPluginClassName(externalResources, TipoPlugin.TOKEN_NEGOZIAZIONE, 
					items, mapNameValue, item, 
					Costanti.ID_NEGOZIAZIONE_CUSTOM_PARSER_PLUGIN_CHOICE, actualValue);			
		}
		
		return actualValue;
	}
	private String dynamicUpdateStoreFile(List<?> items, Map<String, String> mapNameValue, Item item, String actualValue) {
		String type = Costanti.ID_NEGOZIAZIONE_JWT_KEYSTORE_TYPE;
		if(Costanti.ID_HTTPS_TRUSTSTORE_FILE.equals(item.getName())) {
			type = Costanti.ID_HTTPS_TRUSTSTORE_TYPE;
		}
		else if(Costanti.ID_HTTPS_KEYSTORE_FILE.equals(item.getName())) {
			type = Costanti.ID_HTTPS_KEYSTORE_TYPE;
		}
		
		if(Costanti.ID_NEGOZIAZIONE_JWT_KEYSTORE_TYPE.equals(type)) {
			String typeValue = AbstractSecurityProvider.readValue(type, items, mapNameValue);
			if(Costanti.KEYSTORE_TYPE_APPLICATIVO_MODI_VALUE.equals(typeValue) || Costanti.KEYSTORE_TYPE_FRUIZIONE_MODI_VALUE.equals(typeValue)) {
				item.setValue(typeValue);
				item.setType(ItemType.HIDDEN);
				return item.getValue();
			}
		}
		
		return AbstractSecurityProvider.processStoreFile(type, items, mapNameValue, item, actualValue);
	}
	private String dynamicUpdateStorePassword(List<?> items, Map<String, String> mapNameValue, Item item, String actualValue) {
		String type = Costanti.ID_NEGOZIAZIONE_JWT_KEYSTORE_TYPE;
		if(Costanti.ID_HTTPS_TRUSTSTORE_PASSWORD.equals(item.getName())) {
			type = Costanti.ID_HTTPS_TRUSTSTORE_TYPE;
		}
		else if(Costanti.ID_HTTPS_KEYSTORE_PASSWORD.equals(item.getName())) {
			type = Costanti.ID_HTTPS_KEYSTORE_TYPE;
		}
		
		if(Costanti.ID_NEGOZIAZIONE_JWT_KEYSTORE_TYPE.equals(type)) {
			String typeValue = AbstractSecurityProvider.readValue(type, items, mapNameValue);
			if(Costanti.KEYSTORE_TYPE_APPLICATIVO_MODI_VALUE.equals(typeValue) || Costanti.KEYSTORE_TYPE_FRUIZIONE_MODI_VALUE.equals(typeValue)) {
				item.setValue("-");
				item.setType(ItemType.HIDDEN);
				return item.getValue();
			}
		}
		
		return AbstractSecurityProvider.processStorePassword(type, items, mapNameValue, item, actualValue);
	}
	private String dynamicUpdateStoreKeyPassword(List<?> items, Map<String, String> mapNameValue, Item item, String actualValue) {
		String type = Costanti.ID_NEGOZIAZIONE_JWT_KEYSTORE_TYPE;
		if(Costanti.ID_HTTPS_KEYSTORE_PASSWORD_PRIVATE_KEY.equals(item.getName())) {
			type = Costanti.ID_HTTPS_KEYSTORE_TYPE;
		}
		
		if(Costanti.ID_NEGOZIAZIONE_JWT_KEYSTORE_TYPE.equals(type)) {
			String typeValue = AbstractSecurityProvider.readValue(type, items, mapNameValue);
			if(Costanti.KEYSTORE_TYPE_APPLICATIVO_MODI_VALUE.equals(typeValue) || Costanti.KEYSTORE_TYPE_FRUIZIONE_MODI_VALUE.equals(typeValue)) {
				item.setValue("-");
				item.setType(ItemType.HIDDEN);
				return item.getValue();
			}
		}
		
		return AbstractSecurityProvider.processStoreKeyPassword(type, items, mapNameValue, item, actualValue);
	}
}