TokenProvider.java

/*
 * GovWay - A customizable API Gateway 
 * https://govway.org
 * 
 * Copyright (c) 2005-2025 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.ITokenParser;
import org.openspcoop2.pdd.core.token.parser.TipologiaClaims;
import org.openspcoop2.security.message.constants.SecurityConstants;
import org.openspcoop2.security.message.jose.JOSECostanti;
import org.openspcoop2.security.message.jose.SecurityProvider;
import org.openspcoop2.security.message.utils.AbstractSecurityProvider;
import org.openspcoop2.utils.UtilsRuntimeException;
import org.openspcoop2.utils.certificate.byok.BYOKProvider;
import org.openspcoop2.utils.certificate.hsm.HSMUtils;
import org.openspcoop2.utils.certificate.ocsp.OCSPProvider;
import org.openspcoop2.utils.transport.http.HttpRequestMethod;
import org.openspcoop2.utils.transport.http.SSLUtilities;

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

    
    private OCSPProvider ocspProvider;
    private BYOKProvider byokProvider;

    public TokenProvider() {
        this.ocspProvider = new OCSPProvider();
        try {
            this.byokProvider = BYOKProvider.getUnwrapInstance();
        }catch(Exception e) {
            throw new UtilsRuntimeException(e.getMessage(),e);
        }
    }

    private static final String SCONOSCIUTO = "Sconosciuto";
    private static final String NON_SUPPORTATA = "non è supportata";
    private static final String NESSUN_TIPO_CONSEGNA = "Nessuna tipo di consegna (header/url), delle informazioni raccolte, indicata";
    private static final String getPrefixParserType(String parserType) {
        return "È stato indicato un parser '"+parserType+"'";
    }
    private static final String getPrefixTipo(String tipo) {
        return "È stato indicato un tipo '"+tipo+"'";
    }
    
    @Override
    public void validate(Map<String, Properties> mapProperties) throws ProviderException, ProviderValidationException {
        
        Properties pDefault = TokenUtilities.getDefaultProperties(mapProperties);
        
        validateTokenSource(pDefault);
        
        String tokenType = validateTokenType(pDefault);
        
        boolean validazione = TokenUtilities.isValidazioneEnabled(pDefault);
        boolean introspection = TokenUtilities.isIntrospectionEnabled(pDefault);
        boolean userInfo = TokenUtilities.isUserInfoEnabled(pDefault);
        boolean forward = TokenUtilities.isTokenForwardEnabled(pDefault);
                
        if(!validazione &&  !introspection && !userInfo && !forward) {
            throw new ProviderValidationException("Almeno una modalità di elaborazione del token deve essere selezionata");
        }
        
        boolean dynamicDiscovery = TokenUtilities.isDynamicDiscoveryEnabled(pDefault);
        if(dynamicDiscovery) {
            validateDynamicDiscovery(mapProperties, pDefault, validazione, introspection, userInfo);
        }
        
        if(validazione) {
            validateValidazioneJWT(mapProperties, pDefault, tokenType, dynamicDiscovery);
        }
        
        boolean endpointSSL = TokenUtilities.isEnabled(pDefault, Costanti.POLICY_ENDPOINT_HTTPS_STATO);
        if(endpointSSL) {
            validateEndpointSsl(mapProperties);
        }
        
        if(introspection) {
            validateIntrospection(mapProperties, pDefault, dynamicDiscovery);
        }
        
        if(userInfo) {
            validateUserInfo(mapProperties, pDefault, dynamicDiscovery);
        }
                
        if(forward) {
            validateInformazioniRaccolte(mapProperties, pDefault);
        }
    }
    private void validateTokenSource(Properties pDefault) throws ProviderValidationException {
        String position = pDefault.getProperty(Costanti.POLICY_TOKEN_SOURCE);
        if(position==null) {
            throw new ProviderValidationException("Non è stata indicata la posizione del token");
        }
        if(!Costanti.POLICY_TOKEN_SOURCE_RFC6750.equals(position) &&
                !Costanti.POLICY_TOKEN_SOURCE_RFC6750_HEADER.equals(position) &&
                !Costanti.POLICY_TOKEN_SOURCE_RFC6750_FORM.equals(position) && 
                !Costanti.POLICY_TOKEN_SOURCE_RFC6750_URL.equals(position) &&
                !Costanti.POLICY_TOKEN_SOURCE_CUSTOM_HEADER.equals(position) &&
                !Costanti.POLICY_TOKEN_SOURCE_CUSTOM_URL.equals(position) ) {
            throw new ProviderValidationException("La posizione del token indicata '"+position+"' "+NON_SUPPORTATA);
        }
        
        if(Costanti.POLICY_TOKEN_SOURCE_CUSTOM_HEADER.equals(position)) {
            String headerName = pDefault.getProperty(Costanti.POLICY_TOKEN_SOURCE_CUSTOM_HEADER_NAME);
            if(headerName==null || "".equals(headerName)) {
                throw new ProviderValidationException("Non è stato indicato il nome dell'header http che deve contenere il token");
            }
            if(headerName.contains(" ")) {
                throw new ProviderValidationException("Il nome fornito per l'header http che deve contenere il token non deve possedere spazi");
            }
        }
        else if(Costanti.POLICY_TOKEN_SOURCE_CUSTOM_URL.equals(position)) {
            String pName = pDefault.getProperty(Costanti.POLICY_TOKEN_SOURCE_CUSTOM_URL_PROPERTY_NAME);
            if(pName==null) {
                throw new ProviderValidationException("Non è stato indicato il nome della proprietà della URL che deve contenere il token");
            }
            if(pName.contains(" ")) {
                throw new ProviderValidationException("Il nome fornito per la proprietà della URL che deve contenere il token non deve possedere spazi");
            }
        }
    }
    private String validateTokenType(Properties pDefault) throws ProviderValidationException {
        String tokenType = pDefault.getProperty(Costanti.POLICY_TOKEN_TYPE);
        if(tokenType==null) {
            throw new ProviderValidationException("Non è stata indicato il tipo del token");
        }
        if(!Costanti.POLICY_TOKEN_TYPE_OPAQUE.equals(tokenType) &&
                !Costanti.POLICY_TOKEN_TYPE_JWS.equals(tokenType) &&
                !Costanti.POLICY_TOKEN_TYPE_JWE.equals(tokenType)) {
            throw new ProviderValidationException("Il tipo di token indicato '"+tokenType+"' non è supportato");
        }
        
        return tokenType;
    }
    private void validateDynamicDiscovery(Map<String, Properties> mapProperties, Properties pDefault, 
            boolean validazione, boolean introspection, boolean userInfo) throws ProviderValidationException {
        
        String url = pDefault.getProperty(Costanti.POLICY_DISCOVERY_URL);
        InputValidationUtils.validateTextAreaInput(url, "Discovery Document - URL");
        try{
            org.openspcoop2.utils.regexp.RegExpUtilities.validateUrl(url);
        }catch(Exception e){
            throw new ProviderValidationException("La URL fornita per il servizio 'Discovery Document' non è valida: "+e.getMessage());
        }
        
        String dType = pDefault.getProperty(Costanti.POLICY_DISCOVERY_CLAIMS_PARSER_TYPE);
        if(dType==null) {
            throw new ProviderValidationException("Discovery Document URL- non è stata indicato il tipo");
        }
        TipologiaClaims tc = null;
        try {
            tc = TipologiaClaims.valueOf(dType);
        }catch(Exception e) {
            throw new ProviderValidationException("Discovery Document URL- tipo non valido");
        }
        if(TipologiaClaims.MAPPING.equals(tc)) {
            
            Properties p = mapProperties.get(Costanti.DYNAMIC_DISCOVERY_PARSER_COLLECTION_ID);
            if(p==null || p.size()<=0) {
                throw new ProviderValidationException("Non è stata fornita una configurazione per effettuare il parser personalizzato per il servizio di discovery document");
            }
            
            if(validazione) {
                String custom = p.getProperty(Costanti.POLICY_DISCOVERY_JWK_CUSTOM);
                InputValidationUtils.validateTextAreaInput(custom, "Discovery Document URL - JWK Set");
            }
            if(introspection) {
                String custom = p.getProperty(Costanti.POLICY_DISCOVERY_INTROSPECTION_CUSTOM);
                InputValidationUtils.validateTextAreaInput(custom, "Discovery Document URL - Introspection");
            }
            if(userInfo) {
                String custom = p.getProperty(Costanti.POLICY_DISCOVERY_USERINFO_CUSTOM);
                InputValidationUtils.validateTextAreaInput(custom, "Discovery Document URL - UserInfo");
            }
        }
    }
    private void validateValidazioneJWT(Map<String, Properties> mapProperties, Properties pDefault, String tokenType, boolean dynamicDiscovery) throws ProviderValidationException {
        if(!Costanti.POLICY_TOKEN_TYPE_JWS.equals(tokenType) &&
                !Costanti.POLICY_TOKEN_TYPE_JWE.equals(tokenType)) {
            throw new ProviderValidationException("Il tipo di token indicato '"+tokenType+"' non è utilizzabile con una validazione JWT");
        }
        
        if(Costanti.POLICY_TOKEN_TYPE_JWS.equals(tokenType)) {
            validateValidazioneJws(mapProperties, pDefault, dynamicDiscovery);
        }
        else { /**if(Costanti.POLICY_TOKEN_TYPE_JWE.equals(tokenType)) {*/
            validateValidazioneJwe(mapProperties, dynamicDiscovery);
        }
        
        String parserType = pDefault.getProperty(Costanti.POLICY_VALIDAZIONE_CLAIMS_PARSER_TYPE);
        if(parserType==null) {
            throw new ProviderValidationException("Non è stato indicato il parser per i claims da utilizzare dopo la validazione JWT");
        }
        TipologiaClaims tipologiaClaims = null;
        try {
            tipologiaClaims = TipologiaClaims.valueOf(parserType);
            if(tipologiaClaims==null) {
                throw new ProviderValidationException(SCONOSCIUTO);
            }
        }catch(Exception e) {
            throw new ProviderValidationException(getPrefixParserType(parserType)+", per i claims da utilizzare dopo la validazione JWT, sconosciuto");
        }
        if(TipologiaClaims.CUSTOM.name().equals(parserType)) {
            validateValidazioneJwtCustomParser(pDefault);
        }
    }
    private void validateValidazioneJws(Map<String, Properties> mapProperties, Properties pDefault, boolean dynamicDiscovery) throws ProviderValidationException {
        Properties p = mapProperties.get(Costanti.POLICY_VALIDAZIONE_JWS_VERIFICA_PROP_REF_ID);
        if(p==null || p.size()<=0) {
            throw new ProviderValidationException("Non è stata fornita una configurazione per effettuare la validazione JWS");
        }
        
        if(!p.containsKey(SecurityConstants.JOSE_KEYSTORE) && !p.containsKey(SecurityConstants.JOSE_KEYSTORE_JWKSET)) {
            // altrimenti è stato fatto inject del keystore
            if(!dynamicDiscovery) {
                String file = p.getProperty(SecurityConstants.JOSE_KEYSTORE_FILE);
                InputValidationUtils.validateTextAreaInput(file, "Validazione JWT - TrustStore - Location");
            }
            
            String crl = pDefault.getProperty(SecurityConstants.SIGNATURE_CRL);
            if(crl!=null && StringUtils.isNotEmpty(crl)) {
                InputValidationUtils.validateTextAreaInput(crl, "Validazione JWT - TrustStore - CRL File(s)");
            }
        }
    }
    private void validateValidazioneJwe(Map<String, Properties> mapProperties, boolean dynamicDiscovery) throws ProviderValidationException {
        Properties p = mapProperties.get(Costanti.POLICY_VALIDAZIONE_JWE_DECRYPT_PROP_REF_ID);
        if(p==null || p.size()<=0) {
            throw new ProviderValidationException("Non è stata fornita una configurazione per effettuare la validazione JWE");
        }
        
        if(!p.containsKey(SecurityConstants.JOSE_KEYSTORE) && !p.containsKey(SecurityConstants.JOSE_KEYSTORE_JWKSET) &&
            // altrimenti è stato fatto inject del keystore
            !dynamicDiscovery) {
            String file = p.getProperty(SecurityConstants.JOSE_KEYSTORE_FILE);
            InputValidationUtils.validateTextAreaInput(file, "Validazione JWT - KeyStore - Location");
        }
    }
    private void validateValidazioneJwtCustomParser(Properties pDefault) throws ProviderValidationException {
        String pluginType = pDefault.getProperty(Costanti.POLICY_VALIDAZIONE_CLAIMS_PARSER_PLUGIN_TYPE);
        if(pluginType!=null && StringUtils.isNotEmpty(pluginType) && CostantiConfigurazione.POLICY_ID_NON_DEFINITA.equals(pluginType)) {
            String className = pDefault.getProperty(Costanti.POLICY_VALIDAZIONE_CLAIMS_PARSER_CLASS_NAME);
            if(CostantiConfigurazione.POLICY_ID_NON_DEFINITA.equals(className)) {
                throw new ProviderValidationException("Deve essere selezionato un plugin per il parser dei claims del token JWT");
            }
            else {
                if(className==null || "".equals(className)) {
                    throw new ProviderValidationException("Non è stata fornita la classe del parser dei claims da utilizzare dopo la validazione JWT");
                }
                if(className.contains(" ")) {
                    throw new ProviderValidationException("Non indicare spazi nella classe del parser dei claims da utilizzare dopo la validazione JWT");
                }
            }
        }
    }
    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 validateIntrospection(Map<String, Properties> mapProperties, Properties pDefault, boolean dynamicDiscovery) throws ProviderValidationException {
        
        if(!dynamicDiscovery) {
            String url = pDefault.getProperty(Costanti.POLICY_INTROSPECTION_URL);
            InputValidationUtils.validateTextAreaInput(url, "Token Introspection - URL");
            try{
                org.openspcoop2.utils.regexp.RegExpUtilities.validateUrl(url);
            }catch(Exception e){
                throw new ProviderValidationException("La URL fornita per il servizio 'Introspection' non è valida: "+e.getMessage());
            }
        }
        
        TipoTokenRequest tipoTokenRequestEnum = validateIntrospectionTipoToken(pDefault);
        
        HttpRequestMethod httpRequestMethodEnum = validateIntrospectionHttpRequestMethod(pDefault);
        
        validateIntrospectionContentType(pDefault, tipoTokenRequestEnum, httpRequestMethodEnum);
        
        validateIntrospectionParser(pDefault);
        
        boolean basic = TokenUtilities.isEnabled(pDefault, Costanti.POLICY_INTROSPECTION_AUTH_BASIC_STATO);
        if(basic) {
            validateIntrospectionBasicCredentials(pDefault);
        }
        
        boolean bearer = TokenUtilities.isEnabled(pDefault, Costanti.POLICY_INTROSPECTION_AUTH_BEARER_STATO);
        if(bearer) {
            String token = pDefault.getProperty(Costanti.POLICY_INTROSPECTION_AUTH_BEARER_TOKEN);
            InputValidationUtils.validateTextAreaInput(token, "Token Introspection - Autenticazione Bearer - Token");
        }
        
        boolean ssl = TokenUtilities.isEnabled(pDefault, Costanti.POLICY_INTROSPECTION_AUTH_SSL_STATO);
        if(ssl) {
            validateIntrospectionSslCredentials(mapProperties);
        }
    }
    private TipoTokenRequest validateIntrospectionTipoToken(Properties pDefault) throws ProviderValidationException {
        String tipoTokenRequest = pDefault.getProperty(Costanti.POLICY_INTROSPECTION_REQUEST_TOKEN_POSITION);
        if(tipoTokenRequest==null) {
            throw new ProviderValidationException("Non è stato indicato il tipo di spedizione del token da inoltrare al servizio di Introspection");
        }
        TipoTokenRequest tipoTokenRequestEnum = null;
        try {
            tipoTokenRequestEnum = TipoTokenRequest.valueOf(tipoTokenRequest);
            if(tipoTokenRequestEnum==null) {
                throw new ProviderValidationException(SCONOSCIUTO);
            }
        }catch(Exception e) {
            throw new ProviderValidationException(getPrefixTipo(tipoTokenRequest)+" di spedizione del token da inoltrare al servizio di Introspection sconosciuto");
        }
        validateIntrospectionTipoToken(tipoTokenRequestEnum, pDefault);
        return tipoTokenRequestEnum;
    }
    private void validateIntrospectionTipoToken(TipoTokenRequest tipoTokenRequestEnum, Properties pDefault) throws ProviderValidationException {
        switch (tipoTokenRequestEnum) {
        case authorization:
            break;
        case header:
            validateIntrospectionTipoTokenHeader(pDefault);
            break;
        case url:
            validateIntrospectionTipoTokenUrl(pDefault);
            break;
        case form:
            validateIntrospectionTipoTokenForm(pDefault);
            break;
        }
    }
    private void validateIntrospectionTipoTokenHeader(Properties pDefault) throws ProviderValidationException {
        String tmp = pDefault.getProperty(Costanti.POLICY_INTROSPECTION_REQUEST_TOKEN_POSITION_HEADER_NAME);
        if(tmp==null || "".equals(tmp)) {
            throw new ProviderValidationException("Non è stato indicato il nome dell'header http su cui inoltrare il token al servizio di Introspection");
        }
        if(tmp.contains(" ")) {
            throw new ProviderValidationException("Non indicare spazi nel nome dell'header http su cui inoltrare il token al servizio di Introspection");
        }
    }
    private void validateIntrospectionTipoTokenUrl(Properties pDefault) throws ProviderValidationException {
        String tmp = pDefault.getProperty(Costanti.POLICY_INTROSPECTION_REQUEST_TOKEN_POSITION_URL_PROPERTY_NAME);
        if(tmp==null || "".equals(tmp)) {
            throw new ProviderValidationException("Non è stato indicato il nome della proprietà della URL su cui inoltrare il token al servizio di Introspection");
        }
        if(tmp.contains(" ")) {
            throw new ProviderValidationException("Non indicare spazi nel nome della proprietà della URL su cui inoltrare il token al servizio di Introspection");
        }
    }
    private void validateIntrospectionTipoTokenForm(Properties pDefault) throws ProviderValidationException {
        String tmp = pDefault.getProperty(Costanti.POLICY_INTROSPECTION_REQUEST_TOKEN_POSITION_FORM_PROPERTY_NAME);
        if(tmp==null || "".equals(tmp)) {
            throw new ProviderValidationException("Non è stato indicato il nome della proprietà della FORM su cui inoltrare il token al servizio di Introspection");
        }
        if(tmp.contains(" ")) {
            throw new ProviderValidationException("Non indicare spazi nel nome della proprietà della FORM su cui inoltrare il token al servizio di Introspection");
        }
    }
    private HttpRequestMethod validateIntrospectionHttpRequestMethod(Properties pDefault) throws ProviderValidationException {
        String httpRequestMethod = pDefault.getProperty(Costanti.POLICY_INTROSPECTION_HTTP_METHOD);
        if(httpRequestMethod==null) {
            throw new ProviderValidationException("Non è stato indicato il tipo di richiesta HTTP da utilizzare per inoltrare il token al servizio di Introspection");
        }
        HttpRequestMethod httpRequestMethodEnum = null;
        try {
            httpRequestMethodEnum = HttpRequestMethod.valueOf(httpRequestMethod);
            if(httpRequestMethodEnum==null) {
                throw new ProviderValidationException(SCONOSCIUTO);
            }
        }catch(Exception e) {
            throw new ProviderValidationException(getPrefixTipo(httpRequestMethod)+" di richiesta HTTP da utilizzare per inoltrare il token al servizio di Introspection sconosciuto");
        }
        return httpRequestMethodEnum;
    }
    private void validateIntrospectionContentType(Properties pDefault, TipoTokenRequest tipoTokenRequestEnum, HttpRequestMethod httpRequestMethodEnum) throws ProviderValidationException {
        String contentType = pDefault.getProperty(Costanti.POLICY_INTROSPECTION_CONTENT_TYPE);
        if(!TipoTokenRequest.form.equals(tipoTokenRequestEnum) &&
            (   
                HttpRequestMethod.POST.equals(httpRequestMethodEnum) || 
                HttpRequestMethod.PUT.equals(httpRequestMethodEnum) || 
                HttpRequestMethod.PATCH.equals(httpRequestMethodEnum) || 
                HttpRequestMethod.LINK.equals(httpRequestMethodEnum) || 
                HttpRequestMethod.UNLINK.equals(httpRequestMethodEnum)
            ) &&
            (contentType==null || "".equals(contentType))
        ) {
            throw new ProviderValidationException("Non è stato indicato il ContentType da utilizzare nella richiesta HTTP prodotta per inoltrare il token al servizio di Introspection");
                /**                 if(contentType.contains(" ")) {
//                  throw new ProviderValidationException("Non indicare spazi nel ContentType da utilizzare nella richiesta HTTP prodotta per inoltrare il token al servizio di Introspection");
//              }*/
        }
    }
    private void validateIntrospectionParser(Properties pDefault) throws ProviderValidationException {
        String parserType = pDefault.getProperty(Costanti.POLICY_INTROSPECTION_CLAIMS_PARSER_TYPE);
        if(parserType==null) {
            throw new ProviderValidationException("Non è stato indicato il parser per i claims da utilizzare dopo la validazione tramite il servizio di Introspection");
        }
        TipologiaClaims tipologiaClaims = null;
        try {
            tipologiaClaims = TipologiaClaims.valueOf(parserType);
            if(tipologiaClaims==null) {
                throw new ProviderValidationException(SCONOSCIUTO);
            }
        }catch(Exception e) {
            throw new ProviderValidationException(getPrefixParserType(parserType)+", per i claims da utilizzare dopo la validazione del servizio di Introspection, sconosciuto");
        }
        if(TipologiaClaims.CUSTOM.name().equals(parserType)) {
            validateIntrospectionCustomParser(pDefault);
        }
    }
    private void validateIntrospectionCustomParser(Properties pDefault) throws ProviderValidationException {
        String pluginType = pDefault.getProperty(Costanti.POLICY_INTROSPECTION_CLAIMS_PARSER_PLUGIN_TYPE);
        if(pluginType!=null && StringUtils.isNotEmpty(pluginType) && CostantiConfigurazione.POLICY_ID_NON_DEFINITA.equals(pluginType)) {
            String className = pDefault.getProperty(Costanti.POLICY_INTROSPECTION_CLAIMS_PARSER_CLASS_NAME);
            if(CostantiConfigurazione.POLICY_ID_NON_DEFINITA.equals(className)) {
                throw new ProviderValidationException("Deve essere selezionato un plugin per il parser dei claims della risposta del servizio Introspection");
            }
            else {
                if(className==null || "".equals(className)) {
                    throw new ProviderValidationException("Non è stata fornita la classe del parser dei claims da utilizzare dopo la validazione del servizio di Introspection");
                }
                if(className.contains(" ")) {
                    throw new ProviderValidationException("Non indicare spazi nella classe del parser dei claims da utilizzare dopo la validazione del servizio di Introspection");
                }
            }
        }
    }
    private void validateIntrospectionBasicCredentials(Properties pDefault) throws ProviderValidationException {
        String username = pDefault.getProperty(Costanti.POLICY_INTROSPECTION_AUTH_BASIC_USERNAME);
        if(username==null || "".equals(username)) {
            throw new ProviderValidationException("Nonostante sia richiesta una autenticazione 'HttpBasic', non è stato fornito un username da utilizzare durante la connessione verso il servizio di Introspection");
        }
        if(username.contains(" ")) {
            throw new ProviderValidationException("Non indicare spazi nell'username da utilizzare durante la connessione verso il servizio di Introspection");
        }
        String password = pDefault.getProperty(Costanti.POLICY_INTROSPECTION_AUTH_BASIC_PASSWORD);
        if(password==null || "".equals(password)) {
            throw new ProviderValidationException("Nonostante sia richiesta una autenticazione 'HttpBasic', non è stato fornita una password da utilizzare durante la connessione verso il servizio di Introspection");
        }
        if(password.contains(" ")) {
            throw new ProviderValidationException("Non indicare spazi nella password da utilizzare durante la connessione verso il servizio di Introspection");
        }
    }
    private void validateIntrospectionSslCredentials(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 di Introspection");
        }
        
        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 validateUserInfo(Map<String, Properties> mapProperties, Properties pDefault, boolean dynamicDiscovery) throws ProviderValidationException {
        
        if(!dynamicDiscovery) {
            String url = pDefault.getProperty(Costanti.POLICY_USER_INFO_URL);
            InputValidationUtils.validateTextAreaInput(url, "OIDC - UserInfo - URL");
            try{
                org.openspcoop2.utils.regexp.RegExpUtilities.validateUrl(pDefault.getProperty(Costanti.POLICY_USER_INFO_URL));
            }catch(Exception e){
                throw new ProviderValidationException("La URL fornita per il servizio 'OIDC UserInfo' non è valida: "+e.getMessage());
            }
        }
        
        TipoTokenRequest tipoTokenRequestEnum = validateUserInfoTipoToken(pDefault);
        
        HttpRequestMethod httpRequestMethodEnum = validateUserInfoHttpRequestMethod(pDefault);
        
        validateUserInfoContentType(pDefault, tipoTokenRequestEnum, httpRequestMethodEnum);
        
        validateUserInfoParser(pDefault);
        
        boolean basic = TokenUtilities.isEnabled(pDefault, Costanti.POLICY_USER_INFO_AUTH_BASIC_STATO);
        if(basic) {
            validateUserInfoBasicCredentials(pDefault);
        }
        
        boolean bearer = TokenUtilities.isEnabled(pDefault, Costanti.POLICY_USER_INFO_AUTH_BEARER_STATO);
        if(bearer) {
            String token = pDefault.getProperty(Costanti.POLICY_USER_INFO_AUTH_BEARER_TOKEN);
            InputValidationUtils.validateTextAreaInput(token, "OIDC - UserInfo - Autenticazione Bearer - Token");
        }
        
        boolean ssl = TokenUtilities.isEnabled(pDefault, Costanti.POLICY_USER_INFO_AUTH_SSL_STATO);
        if(ssl) {
            validateUserInfoSslCredentials(mapProperties);
        }
    }
    private TipoTokenRequest validateUserInfoTipoToken(Properties pDefault) throws ProviderValidationException {
        String tipoTokenRequest = pDefault.getProperty(Costanti.POLICY_USER_INFO_REQUEST_TOKEN_POSITION);
        if(tipoTokenRequest==null) {
            throw new ProviderValidationException("Non è stato indicato il tipo di spedizione del token da inoltrare al servizio di UserInfo");
        }
        TipoTokenRequest tipoTokenRequestEnum = null;
        try {
            tipoTokenRequestEnum = TipoTokenRequest.valueOf(tipoTokenRequest);
            if(tipoTokenRequestEnum==null) {
                throw new ProviderValidationException(SCONOSCIUTO);
            }
        }catch(Exception e) {
            throw new ProviderValidationException(getPrefixTipo(tipoTokenRequest)+" di spedizione del token da inoltrare al servizio di UserInfo sconosciuto");
        }
        validateUserInfoTipoToken(tipoTokenRequestEnum, pDefault);
        return tipoTokenRequestEnum;
    }
    private void validateUserInfoTipoToken(TipoTokenRequest tipoTokenRequestEnum, Properties pDefault) throws ProviderValidationException {
        switch (tipoTokenRequestEnum) {
        case authorization:
            break;
        case header:
            validateUserInfoTipoTokenHeader(pDefault);
            break;
        case url:
            validateUserInfoTipoTokenUrl(pDefault);
            break;
        case form:
            validateUserInfoTipoTokenFrom(pDefault);
            break;
        }
    }
    private void validateUserInfoTipoTokenHeader(Properties pDefault) throws ProviderValidationException {
        String tmp = pDefault.getProperty(Costanti.POLICY_USER_INFO_REQUEST_TOKEN_POSITION_HEADER_NAME);
        if(tmp==null || "".equals(tmp)) {
            throw new ProviderValidationException("Non è stato indicato il nome dell'header http su cui inoltrare il token al servizio di UserInfo");
        }
        if(tmp.contains(" ")) {
            throw new ProviderValidationException("Non indicare spazi nel nome dell'header http su cui inoltrare il token al servizio di UserInfo");
        }
    }
    private void validateUserInfoTipoTokenUrl(Properties pDefault) throws ProviderValidationException {
        String tmp = pDefault.getProperty(Costanti.POLICY_USER_INFO_REQUEST_TOKEN_POSITION_URL_PROPERTY_NAME);
        if(tmp==null || "".equals(tmp)) {
            throw new ProviderValidationException("Non è stato indicato il nome della proprietà della URL su cui inoltrare il token al servizio di UserInfo");
        }
        if(tmp.contains(" ")) {
            throw new ProviderValidationException("Non indicare spazi nel nome della proprietà della URL su cui inoltrare il token al servizio di UserInfo");
        }
    }
    private void validateUserInfoTipoTokenFrom(Properties pDefault) throws ProviderValidationException {
        String tmp = pDefault.getProperty(Costanti.POLICY_USER_INFO_REQUEST_TOKEN_POSITION_FORM_PROPERTY_NAME);
        if(tmp==null || "".equals(tmp)) {
            throw new ProviderValidationException("Non è stato indicato il nome della proprietà della FORM su cui inoltrare il token al servizio di UserInfo");
        }
        if(tmp.contains(" ")) {
            throw new ProviderValidationException("Non indicare spazi nel nome della proprietà della FORM su cui inoltrare il token al servizio di UserInfo");
        }
    }
    private HttpRequestMethod validateUserInfoHttpRequestMethod(Properties pDefault) throws ProviderValidationException {
        String httpRequestMethod = pDefault.getProperty(Costanti.POLICY_USER_INFO_HTTP_METHOD);
        if(httpRequestMethod==null) {
            throw new ProviderValidationException("Non è stato indicato il tipo di richiesta HTTP da utilizzare per inoltrare il token al servizio di UserInfo");
        }
        HttpRequestMethod httpRequestMethodEnum = null;
        try {
            httpRequestMethodEnum = HttpRequestMethod.valueOf(httpRequestMethod);
            if(httpRequestMethodEnum==null) {
                throw new ProviderValidationException(SCONOSCIUTO);
            }
        }catch(Exception e) {
            throw new ProviderValidationException(getPrefixTipo(httpRequestMethod)+" di richiesta HTTP da utilizzare per inoltrare il token al servizio di UserInfo sconosciuto");
        }
        return httpRequestMethodEnum;
    }
    private void validateUserInfoContentType(Properties pDefault, TipoTokenRequest tipoTokenRequestEnum, HttpRequestMethod httpRequestMethodEnum) throws ProviderValidationException {
        String contentType = pDefault.getProperty(Costanti.POLICY_USER_INFO_CONTENT_TYPE);
        if(!TipoTokenRequest.form.equals(tipoTokenRequestEnum) &&
            (
                HttpRequestMethod.POST.equals(httpRequestMethodEnum) || 
                HttpRequestMethod.PUT.equals(httpRequestMethodEnum) || 
                HttpRequestMethod.PATCH.equals(httpRequestMethodEnum) || 
                HttpRequestMethod.LINK.equals(httpRequestMethodEnum) || 
                HttpRequestMethod.UNLINK.equals(httpRequestMethodEnum) 
            ) &&
            (contentType==null || "".equals(contentType))
            ) {
            throw new ProviderValidationException("Non è stato indicato il ContentType da utilizzare nella richiesta HTTP prodotta per inoltrare il token al servizio di UserInfo");
                /**                 if(contentType.contains(" ")) {
//                  throw new ProviderValidationException("Non indicare spazi nel ContentType da utilizzare nella richiesta HTTP prodotta per inoltrare il token al servizio di UserInfo");
//              }*/
        }
    }
    private void validateUserInfoParser(Properties pDefault) throws ProviderValidationException {
        String parserType = pDefault.getProperty(Costanti.POLICY_USER_INFO_CLAIMS_PARSER_TYPE);
        if(parserType==null) {
            throw new ProviderValidationException("Non è stato indicato il parser per i claims da utilizzare dopo la validazione tramite il servizio di UserInfo");
        }
        TipologiaClaims tipologiaClaims = null;
        try {
            tipologiaClaims = TipologiaClaims.valueOf(parserType);
            if(tipologiaClaims==null) {
                throw new ProviderValidationException(SCONOSCIUTO);
            }
        }catch(Exception e) {
            throw new ProviderValidationException(getPrefixParserType(parserType)+", per i claims da utilizzare dopo la validazione del servizio di UserInfo, sconosciuto");
        }
        if(TipologiaClaims.CUSTOM.name().equals(parserType)) {
            validateUserInfoCustomParser(pDefault);
        }
    }
    private void validateUserInfoCustomParser(Properties pDefault) throws ProviderValidationException {
        String pluginType = pDefault.getProperty(Costanti.POLICY_USER_INFO_CLAIMS_PARSER_PLUGIN_TYPE);
        if(pluginType!=null && StringUtils.isNotEmpty(pluginType) && CostantiConfigurazione.POLICY_ID_NON_DEFINITA.equals(pluginType)) {
            String className = pDefault.getProperty(Costanti.POLICY_USER_INFO_CLAIMS_PARSER_CLASS_NAME);
            if(CostantiConfigurazione.POLICY_ID_NON_DEFINITA.equals(className)) {
                throw new ProviderValidationException("Deve essere selezionato un plugin per il parser dei claims della risposta del servizio UserInfo");
            }
            else {
                if(className==null || "".equals(className)) {
                    throw new ProviderValidationException("Non è stata fornita la classe del parser dei claims da utilizzare dopo la validazione del servizio di UserInfo");
                }
                if(className.contains(" ")) {
                    throw new ProviderValidationException("Non indicare spazi nella classe del parser dei claims da utilizzare dopo la validazione del servizio di UserInfo");
                }
            }
        }
    }
    private void validateUserInfoBasicCredentials(Properties pDefault) throws ProviderValidationException {
        String username = pDefault.getProperty(Costanti.POLICY_USER_INFO_AUTH_BASIC_USERNAME);
        if(username==null || "".equals(username)) {
            throw new ProviderValidationException("Nonostante sia richiesta una autenticazione 'HttpBasic', non è stato fornito un username da utilizzare durante la connessione verso il servizio di UserInfo");
        }
        if(username.contains(" ")) {
            throw new ProviderValidationException("Non indicare spazi nell'username da utilizzare durante la connessione verso il servizio di UserInfo");
        }
        String password = pDefault.getProperty(Costanti.POLICY_USER_INFO_AUTH_BASIC_PASSWORD);
        if(password==null || "".equals(password)) {
            throw new ProviderValidationException("Nonostante sia richiesta una autenticazione 'HttpBasic', non è stato fornita una password da utilizzare durante la connessione verso il servizio di UserInfo");
        }
        if(password.contains(" ")) {
            throw new ProviderValidationException("Non indicare spazi nella password da utilizzare durante la connessione verso il servizio di UserInfo");
        }
    }
    private void validateUserInfoSslCredentials(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 di UserInfo");
        }
        
        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 validateInformazioniRaccolte(Map<String, Properties> mapProperties, Properties pDefault) throws ProviderValidationException {
        boolean forwardTrasparente = TokenUtilities.isEnabled(pDefault, Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_STATO);
        boolean forwardInformazioniRaccolte = TokenUtilities.isEnabled(pDefault, Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_STATO);

        if(!forwardTrasparente && !forwardInformazioniRaccolte) {
            throw new ProviderValidationException("Almeno una modalità di forward del token deve essere selezionata");
        }
        
        if(forwardTrasparente) {
            validateInformazioniRaccolteForwardTrasparente(pDefault);
        }
        
        if(forwardInformazioniRaccolte) {
            validateInformazioniRaccolteForward(mapProperties, pDefault);       
        }
    }
    private void validateInformazioniRaccolteForwardTrasparente(Properties pDefault) throws ProviderValidationException {
        String mode = pDefault.getProperty(Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE);
        if(mode==null) {
            throw new ProviderValidationException("Nessuna modalità di forward trasparente indicata");
        }
        if(!Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_AS_RECEIVED.equals(mode) &&
                !Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_RFC6750_HEADER.equals(mode) &&
                !Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_RFC6750_URL.equals(mode) &&
                !Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_CUSTOM_HEADER.equals(mode) &&
                !Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_CUSTOM_URL.equals(mode)
                ) {
            throw new ProviderValidationException("La modalità di forward trasparente indicata '"+mode+"' "+NON_SUPPORTATA);    
        }
        if(Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_CUSTOM_HEADER.equals(mode)) {
            String hdr = pDefault.getProperty(Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_CUSTOM_HEADER_NAME);
            if(hdr==null || "".equals(hdr)) {
                throw new ProviderValidationException("La modalità di forward trasparente 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 trasparente");
            }
        }
        else if(Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_CUSTOM_URL.equals(mode)) {
            String url = pDefault.getProperty(Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_CUSTOM_URL_PARAMETER_NAME);
            if(url==null || "".equals(url)) {
                throw new ProviderValidationException("La modalità di forward trasparente indicata prevede l'indicazione del nome di una proprietà della url");
            }
            if(url.contains(" ")) {
                throw new ProviderValidationException("Non indicare spazi nel nome della proprietà della url indicata per la modalità di forward trasparente");
            }
        }
    }
    private void validateInformazioniRaccolteForward(Map<String, Properties> mapProperties, Properties pDefault) throws ProviderValidationException {
        String mode = pDefault.getProperty(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE);
        if(mode==null) {
            throw new ProviderValidationException("Nessuna modalità di forward, delle informazioni raccolte, indicata");
        }
        if(!Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_OP2_HEADERS.equals(mode) &&
                !Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_OP2_JSON.equals(mode) &&
                !Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_OP2_JWS.equals(mode) &&
                !Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JWS.equals(mode) &&
                !Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JWE.equals(mode) &&
                !Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JSON.equals(mode) 
                ) {
            throw new ProviderValidationException("La modalità di forward, delle informazioni raccolte, indicata '"+mode+"' "+NON_SUPPORTATA);  
        }
        if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_OP2_JSON.equals(mode) ||
            Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JSON.equals(mode) 
                ) {
            String base64 = pDefault.getProperty(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_ENCODE_BASE64);
            if(base64==null) {
                throw new ProviderValidationException("Nessuna indicazione sull'encoding 'Base64' fornito; Tale indicazione è richiesta dalla modalità di forward, delle informazioni raccolte, indicata: "+mode);
            }
        }
        if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JWS.equals(mode) ||
                Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JWE.equals(mode) ||
                Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JSON.equals(mode) 
                    ) {
            validateInformazioniRaccolteForwardJson(pDefault, mode);
        }
        if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_OP2_JWS.equals(mode) ||
                Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JWS.equals(mode) 
                    ) {
            validateInformazioniRaccolteForwardJws(mapProperties);
        }
        if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JWE.equals(mode) 
                    ) {
            validateInformazioniRaccolteForwardJwe(mapProperties);
        }
    }
    private void validateInformazioniRaccolteForwardJson(Properties pDefault, String mode) throws ProviderValidationException {
        boolean forwardValidazioneJWT = TokenUtilities.isEnabled(pDefault, Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_VALIDAZIONE_JWT);    
        boolean forwardIntrospection = TokenUtilities.isEnabled(pDefault, Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_INTROSPECTION);
        boolean forwardUserInfo = TokenUtilities.isEnabled(pDefault, Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_USER_INFO);
        if(!forwardValidazioneJWT && !forwardIntrospection && !forwardUserInfo) {
            throw new ProviderValidationException("Almeno una scelta tra 'Validazione JWT', 'Introspection' o 'OIDC UserInfo' deve essere selezionata per inoltrare le informazioni raccolte all'applicativo erogatore tramite la modalità scelta: "+mode);
        }
        
        String indicataModalitaSconosciuta = ", indicata per le informazioni raccolte, sconosciuta";
        
        if(forwardValidazioneJWT) {
            validateInformazioniRaccolteForwardJsonValidazioneJWT(pDefault, indicataModalitaSconosciuta);
        }
        
        if(forwardIntrospection) {
            validateInformazioniRaccolteForwardJsonIntrospection(pDefault, indicataModalitaSconosciuta);
        }
        
        if(forwardUserInfo) {
            validateInformazioniRaccolteForwardJsonUserInfo(pDefault, indicataModalitaSconosciuta);
        }
    }
    private void validateInformazioniRaccolteForwardJsonValidazioneJWT(Properties pDefault, String indicataModalitaSconosciuta) throws ProviderValidationException {
        String modeForward = pDefault.getProperty(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_VALIDAZIONE_JWT_MODE);
        if(modeForward==null) {
            throw new ProviderValidationException(NESSUN_TIPO_CONSEGNA);
        }
        if(!Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_NO_OPENSPCOOP_CUSTOM_HEADER.equals(modeForward) &&
                !Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_NO_OPENSPCOOP_CUSTOM_URL.equals(modeForward) 
                    ) {
            throw new ProviderValidationException("(Validazione JWT) Tipo di consegna '"+modeForward+"'"+indicataModalitaSconosciuta);
        }
        if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_NO_OPENSPCOOP_CUSTOM_HEADER.equals(modeForward)) {
            String name = pDefault.getProperty(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_VALIDAZIONE_JWT_MODE_HEADER_NAME);
            if(name==null || "".equals(name)) {
                throw new ProviderValidationException("(Validazione JWT) Il tipo di consegna (header), delle informazioni raccolte, richiede la definizione di un nome di un header http");
            }
            if(name.contains(" ")) {
                throw new ProviderValidationException("Non indicare spazi nel nome dell'header http (Forward ValidazioneJWT-Header)");
            }
        }
        else { /** if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_NO_OPENSPCOOP_CUSTOM_URL.equals(modeForward)) {*/
            String name = pDefault.getProperty(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_VALIDAZIONE_JWT_MODE_URL_PARAMETER_NAME);
            if(name==null || "".equals(name)) {
                throw new ProviderValidationException("(Validazione JWT) Il tipo di consegna (url), delle informazioni raccolte, richiede la definizione di un nome di un parametro della URL");
            }
            if(name.contains(" ")) {
                throw new ProviderValidationException("Non indicare spazi nel nome del parametro della url (Forward ValidazioneJWT-ParametroURL)");
            }
        }
    }
    private void validateInformazioniRaccolteForwardJsonIntrospection(Properties pDefault, String indicataModalitaSconosciuta) throws ProviderValidationException {
        String modeForward = pDefault.getProperty(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_INTROSPECTION_MODE);
        if(modeForward==null) {
            throw new ProviderValidationException(NESSUN_TIPO_CONSEGNA);
        }
        if(!Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_NO_OPENSPCOOP_CUSTOM_HEADER.equals(modeForward) &&
                !Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_NO_OPENSPCOOP_CUSTOM_URL.equals(modeForward) 
                    ) {
            throw new ProviderValidationException("(Introspection) Tipo di consegna '"+modeForward+"'"+indicataModalitaSconosciuta);
        }
        if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_NO_OPENSPCOOP_CUSTOM_HEADER.equals(modeForward)) {
            String name = pDefault.getProperty(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_INTROSPECTION_MODE_HEADER_NAME);
            if(name==null || "".equals(name)) {
                throw new ProviderValidationException("(Introspection) Il tipo di consegna (header), delle informazioni raccolte, richiede la definizione di un nome di un header http");
            }
            if(name.contains(" ")) {
                throw new ProviderValidationException("Non indicare spazi nel nome dell'header http (Forward Introspection-Header)");
            }
        }
        else { /** if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_NO_OPENSPCOOP_CUSTOM_URL.equals(modeForward)) { */
            String name = pDefault.getProperty(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_INTROSPECTION_MODE_URL_PARAMETER_NAME);
            if(name==null || "".equals(name)) {
                throw new ProviderValidationException("(Introspection) Il tipo di consegna (url), delle informazioni raccolte, richiede la definizione di un nome di un parametro della URL");
            }
            if(name.contains(" ")) {
                throw new ProviderValidationException("Non indicare spazi nel nome del parametro della url (Forward Introspection-ParametroURL)");
            }
        }
    }
    private void validateInformazioniRaccolteForwardJsonUserInfo(Properties pDefault, String indicataModalitaSconosciuta) throws ProviderValidationException {
        String modeForward = pDefault.getProperty(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_USER_INFO_MODE);
        if(modeForward==null) {
            throw new ProviderValidationException(NESSUN_TIPO_CONSEGNA);
        }
        if(!Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_NO_OPENSPCOOP_CUSTOM_HEADER.equals(modeForward) &&
                !Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_NO_OPENSPCOOP_CUSTOM_URL.equals(modeForward) 
                    ) {
            throw new ProviderValidationException("(UserInfo) Tipo di consegna '"+modeForward+"'"+indicataModalitaSconosciuta);
        }
        if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_NO_OPENSPCOOP_CUSTOM_HEADER.equals(modeForward)) {
            String name = pDefault.getProperty(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_USER_INFO_MODE_HEADER_NAME);
            if(name==null || "".equals(name)) {
                throw new ProviderValidationException("(UserInfo) Il tipo di consegna (header), delle informazioni raccolte, richiede la definizione di un nome di un header http");
            }
            if(name.contains(" ")) {
                throw new ProviderValidationException("Non indicare spazi nel nome dell'header http (Forward UserInfo-Header)");
            }
        }
        else { /** if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_NO_OPENSPCOOP_CUSTOM_URL.equals(modeForward)) {*/
            String name = pDefault.getProperty(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_USER_INFO_MODE_URL_PARAMETER_NAME);
            if(name==null || "".equals(name)) {
                throw new ProviderValidationException("(UserInfo) Il tipo di consegna (url), delle informazioni raccolte, richiede la definizione di un nome di un parametro della URL");
            }
            if(name.contains(" ")) {
                throw new ProviderValidationException("Non indicare spazi nel nome del parametro della url (Forward UserInfo-ParametroURL)");
            }
        }
    }
    private void validateInformazioniRaccolteForwardJws(Map<String, Properties> mapProperties) throws ProviderValidationException {
        Properties p = mapProperties.get(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_SIGNATURE_PROP_REF_ID);
        if(p==null || p.size()<=0) {
            throw new ProviderValidationException("La modalità di forward, delle informazioni raccolte, selezionata richiede una configurazione per poter attuare la firma JWS; configurazione non riscontrata");
        }
        
        if(!p.containsKey(SecurityConstants.JOSE_KEYSTORE) && !p.containsKey(SecurityConstants.JOSE_KEYSTORE_JWKSET)) {
            // altrimenti è stato fatto inject del keystore
            String file = p.getProperty(SecurityConstants.JOSE_KEYSTORE_FILE);
            InputValidationUtils.validateTextAreaInput(file, "Token Forward - JWS KeyStore - File");
            
            String fileChiavePubblica = p.getProperty(SecurityConstants.JOSE_KEYSTORE_PUBLIC_KEY);
            if(fileChiavePubblica!=null && StringUtils.isNotEmpty(fileChiavePubblica)) {
                InputValidationUtils.validateTextAreaInput(file, "Token Forward - JWS KeyStore - Chiave Pubblica");
            }
        }
    }
    private void validateInformazioniRaccolteForwardJwe(Map<String, Properties> mapProperties) throws ProviderValidationException {
        Properties p = mapProperties.get(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_ENCRYP_PROP_REF_ID);
        if(p==null || p.size()<=0) {
            throw new ProviderValidationException("La modalità di forward, delle informazioni raccolte, selezionata richiede una configurazione per poter attuare la cifratura JWE; configurazione non riscontrata");
        }
        
        if(!p.containsKey(SecurityConstants.JOSE_KEYSTORE) && !p.containsKey(SecurityConstants.JOSE_KEYSTORE_JWKSET)) {
            // altrimenti è stato fatto inject del keystore
            String file = p.getProperty(SecurityConstants.JOSE_KEYSTORE_FILE);
            InputValidationUtils.validateTextAreaInput(file, "Token Forward - JWE KeyStore - File");
        }
    }
    
    @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{
        if(Costanti.ID_INTROSPECTION_HTTP_METHOD.equals(id) ||
                Costanti.ID_USER_INFO_HTTP_METHOD.equals(id)) {
            return getHttpRequestMethodValues();
        }
        else if(Costanti.ID_TIPOLOGIA_HTTPS.equals(id)) {
            return getTipologiaHttpsValues();
        }
        else if(JOSECostanti.ID_ENCRYPT_KEY_ALGORITHM.equals(id) ||
                JOSECostanti.ID_ENCRYPT_CONTENT_ALGORITHM.equals(id) ||
                Costanti.ID_JWS_SIGNATURE_ALGORITHM.equals(id) ||
                Costanti.ID_JWS_ENCRYPT_KEY_ALGORITHM.equals(id) ||
                Costanti.ID_JWS_ENCRYPT_CONTENT_ALGORITHM.equals(id)) {
            return getSecProviderValues(id);
        }
        else if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE.equals(id) || 
                Costanti.ID_VALIDAZIONE_JWT_KEYSTORE_TYPE.equals(id) ||
                Costanti.ID_HTTPS_TRUSTSTORE_TYPE.equals(id) ||
                Costanti.ID_HTTPS_KEYSTORE_TYPE.equals(id)  ||
                Costanti.ID_TOKEN_FORWARD_JWS_KEYSTORE_TYPE.equals(id)  ||
                Costanti.ID_TOKEN_FORWARD_JWE_KEYSTORE_TYPE.equals(id)) {
            return getStoreType(id,true);
        }
        else if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE.equals(id)) {
            return Costanti.getIdValidazioneJwtTruststoreTypeSelectCertificateValues();
        }
        else if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_JWK_PUBLIC_KEY.equals(id)) {
            return Costanti.getIdValidazioneJwtTruststoreTypeSelectJwkPublicKeyValues();
        }
        else if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_OCSP_POLICY.equals(id) ||
                Costanti.ID_HTTPS_TRUSTSTORE_OCSP_POLICY.equals(id)) {
            return this.ocspProvider.getValues();
        }
        else if(Costanti.ID_TOKEN_FORWARD_JWS_KEYSTORE_BYOK_POLICY.equals(id) ||
                Costanti.ID_TOKEN_FORWARD_JWE_KEYSTORE_BYOK_POLICY.equals(id) ||
                Costanti.ID_HTTPS_KEYSTORE_BYOK_POLICY.equals(id) ||
                Costanti.ID_VALIDAZIONE_JWT_KEYSTORE_BYOK_POLOCY.equals(id) ) {
            return this.byokProvider.getValues();
        }
        else {
            return getValuesContinue1(id, externalResources);
        }
    }
    private List<String> getValuesContinue1(String id, ExternalResources externalResources) throws ProviderException{
        List<String> l = null;
        if(Costanti.ID_DYNAMIC_DISCOVERY_CUSTOM_PARSER_PLUGIN_CHOICE.equals(id)) {
            return TokenUtilities.getTokenPluginValues(externalResources, TipoPlugin.TOKEN_DYNAMIC_DISCOVERY);
        }
        else if(Costanti.ID_VALIDAZIONE_JWT_CUSTOM_PARSER_PLUGIN_CHOICE.equals(id)
                ||
                Costanti.ID_INTROSPECTION_CUSTOM_PARSER_PLUGIN_CHOICE.equals(id)
                ||
                Costanti.ID_USER_INFO_CUSTOM_PARSER_PLUGIN_CHOICE.equals(id)) {
            return TokenUtilities.getTokenPluginValues(externalResources, TipoPlugin.TOKEN_VALIDAZIONE);
        }
        return l;
    }
    private List<String> getHttpRequestMethodValues() {
        List<String> methodsList = new ArrayList<>();
        HttpRequestMethod [] methods = HttpRequestMethod.values();
        for (int i = 0; i < methods.length; i++) {
            methodsList.add(methods[i].name());
        }
        return methodsList;
    }
    private List<String> getTipologiaHttpsValues() {
        List<String> tipologie = null;
        try{
            tipologie = SSLUtilities.getSSLSupportedProtocols();
        }catch(Exception e){
            tipologie = SSLUtilities.getAllSslProtocol();
        }
        return tipologie;
    }
    private List<String> getSecProviderValues(String id) throws ProviderException {
        SecurityProvider secProvider = new SecurityProvider();
        if(Costanti.ID_JWS_SIGNATURE_ALGORITHM.equals(id)) {
            return secProvider.getValues(JOSECostanti.ID_SIGNATURE_ALGORITHM);
        }
        else if(Costanti.ID_JWS_ENCRYPT_KEY_ALGORITHM.equals(id) || JOSECostanti.ID_ENCRYPT_KEY_ALGORITHM.equals(id)) {
            return secProvider.getValues(JOSECostanti.ID_ENCRYPT_KEY_ALGORITHM);
        }
        else{/**else if(Costanti.ID_JWS_ENCRYPT_CONTENT_ALGORITHM.equals(id) || JOSECostanti.ID_ENCRYPT_CONTENT_ALGORITHM.equals(id)) {*/
            return secProvider.getValues(JOSECostanti.ID_ENCRYPT_CONTENT_ALGORITHM);
        }
    }

    @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(JOSECostanti.ID_ENCRYPT_KEY_ALGORITHM.equals(id) ||
                JOSECostanti.ID_ENCRYPT_CONTENT_ALGORITHM.equals(id) ||
                Costanti.ID_JWS_SIGNATURE_ALGORITHM.equals(id) ||
                Costanti.ID_JWS_ENCRYPT_KEY_ALGORITHM.equals(id) ||
                Costanti.ID_JWS_ENCRYPT_CONTENT_ALGORITHM.equals(id)) {
            return getLabelsEncryption(id);
        }
        else if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE.equals(id) || 
                Costanti.ID_VALIDAZIONE_JWT_KEYSTORE_TYPE.equals(id) ||
                Costanti.ID_HTTPS_TRUSTSTORE_TYPE.equals(id) ||
                Costanti.ID_HTTPS_KEYSTORE_TYPE.equals(id) ||
                Costanti.ID_TOKEN_FORWARD_JWS_KEYSTORE_TYPE.equals(id) ||
                Costanti.ID_TOKEN_FORWARD_JWE_KEYSTORE_TYPE.equals(id)) {
            return getStoreType(id,false);
        }
        else if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE.equals(id)) {
            return Costanti.getIdValidazioneJwtTruststoreTypeSelectCertificateLabels();
        }
        else if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_JWK_PUBLIC_KEY.equals(id)) {
            return Costanti.getIdValidazioneJwtTruststoreTypeSelectJwkPublicKeyLabels();
        }
        else if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_OCSP_POLICY.equals(id) ||
                Costanti.ID_HTTPS_TRUSTSTORE_OCSP_POLICY.equals(id)) {
            return this.ocspProvider.getLabels();
        }
        else if(Costanti.ID_TOKEN_FORWARD_JWS_KEYSTORE_BYOK_POLICY.equals(id) ||
                Costanti.ID_TOKEN_FORWARD_JWE_KEYSTORE_BYOK_POLICY.equals(id) ||
                Costanti.ID_HTTPS_KEYSTORE_BYOK_POLICY.equals(id) ||
                Costanti.ID_VALIDAZIONE_JWT_KEYSTORE_BYOK_POLOCY.equals(id)) {
            return this.byokProvider.getLabels();
        }
        else {
            return getLabelsContinue1(id, externalResources);
        }
    }
    private List<String> getLabelsEncryption(String id) throws ProviderException{
        SecurityProvider secProvider = new SecurityProvider();
        if(Costanti.ID_JWS_SIGNATURE_ALGORITHM.equals(id)) {
            return secProvider.getLabels(JOSECostanti.ID_SIGNATURE_ALGORITHM);
        }
        else if(Costanti.ID_JWS_ENCRYPT_KEY_ALGORITHM.equals(id) || JOSECostanti.ID_ENCRYPT_KEY_ALGORITHM.equals(id)) {
            return secProvider.getLabels(JOSECostanti.ID_ENCRYPT_KEY_ALGORITHM);
        }
        else{/**else if(Costanti.ID_JWS_ENCRYPT_CONTENT_ALGORITHM.equals(id) || JOSECostanti.ID_ENCRYPT_CONTENT_ALGORITHM.equals(id)) {*/
            return secProvider.getLabels(JOSECostanti.ID_ENCRYPT_CONTENT_ALGORITHM);
        }
    }
    private List<String> getLabelsContinue1(String id, ExternalResources externalResources) throws ProviderException{
        if(Costanti.ID_DYNAMIC_DISCOVERY_CUSTOM_PARSER_PLUGIN_CHOICE.equals(id)) {
            return TokenUtilities.getTokenPluginLabels(externalResources, TipoPlugin.TOKEN_DYNAMIC_DISCOVERY);
        }
        else if(Costanti.ID_VALIDAZIONE_JWT_CUSTOM_PARSER_PLUGIN_CHOICE.equals(id)
                ||
                Costanti.ID_INTROSPECTION_CUSTOM_PARSER_PLUGIN_CHOICE.equals(id)
                ||
                Costanti.ID_USER_INFO_CUSTOM_PARSER_PLUGIN_CHOICE.equals(id)) {
            return TokenUtilities.getTokenPluginLabels(externalResources, TipoPlugin.TOKEN_VALIDAZIONE);
        }
        return this.getValues(id); // torno uguale ai valori negli altri casi
    }
    
    private List<String> getStoreType(String id,boolean value){
        boolean trustStore = true;
        boolean secret = false;
        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);
        addStoreTypeJWK(id, l, value);
        addStoreTypePrivatePubliKey(id, l, value);
        if(Costanti.ID_VALIDAZIONE_JWT_KEYSTORE_TYPE.equals(id) ||
                Costanti.ID_TOKEN_FORWARD_JWE_KEYSTORE_TYPE.equals(id)) {
            l.add(value ? SecurityConstants.KEYSTORE_TYPE_JCEKS_VALUE : SecurityConstants.KEYSTORE_TYPE_JCEKS_LABEL);
            secret = true;
        }
        
        if(Costanti.ID_VALIDAZIONE_JWT_KEYSTORE_TYPE.equals(id) ||
                Costanti.ID_HTTPS_KEYSTORE_TYPE.equals(id) ||
                Costanti.ID_TOKEN_FORWARD_JWS_KEYSTORE_TYPE.equals(id) ||
                Costanti.ID_TOKEN_FORWARD_JWE_KEYSTORE_TYPE.equals(id)) {
            trustStore = false;
        }
        HSMUtils.fillTipologieKeystore(trustStore, false, l);
        
        if(secret) {
            // aggiunto info mancanti come secret
            addStoreTypeSecret(l);
        }
        return l;
    }
    private void addStoreTypeJWK(String id, List<String> l, boolean value) {
        if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE.equals(id) || 
                Costanti.ID_VALIDAZIONE_JWT_KEYSTORE_TYPE.equals(id) ||
                Costanti.ID_TOKEN_FORWARD_JWS_KEYSTORE_TYPE.equals(id) ||
                Costanti.ID_TOKEN_FORWARD_JWE_KEYSTORE_TYPE.equals(id)) {
            l.add(value ? SecurityConstants.KEYSTORE_TYPE_JWK_VALUE: SecurityConstants.KEYSTORE_TYPE_JWK_LABEL);
        }
    }
    private void addStoreTypePrivatePubliKey(String id, List<String> l, boolean value) {
        if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE.equals(id)) {
            l.add(value ? SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE: SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_LABEL);
        }
        if(Costanti.ID_TOKEN_FORWARD_JWS_KEYSTORE_TYPE.equals(id)) {
            l.add(value ? SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE: SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_LABEL);
        }
    }
    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 getNote(String id, String actualValue) throws ProviderException{
        if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE.equals(id)) {
            if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_ALIAS.equals(actualValue)) {
                return Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_NOTE_ALIAS;
            }
            else if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5C.equals(actualValue)) {
                return Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_NOTE_X5C;
            }
            else if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5T256.equals(actualValue)) {
                return Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_NOTE_X5T256;
            }
            else if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5C_X5T256.equals(actualValue)) {
                return Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_NOTE_X5C_X5T256;
            }
            else if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_KID.equals(actualValue)) {
                return Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_NOTE_KID;
            }
            else if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5U.equals(actualValue)) {
                return Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_NOTE_X5U;
            }
        }
        else if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_JWK_PUBLIC_KEY.equals(id)) {
            if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_JWK_PUBLIC_KEY_VALUE_ALIAS.equals(actualValue)) {
                return Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_JWK_PUBLIC_KEY_NOTE_ALIAS;
            }
            else if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_JWK_PUBLIC_KEY_VALUE_KID.equals(actualValue)) {
                return Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_JWK_PUBLIC_KEY_NOTE_KID;
            }
        }
        return null;
    }
    
    @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_INTROSPECTION_HTTP_METHOD.equals(id) ||
                Costanti.ID_USER_INFO_HTTP_METHOD.equals(id)) {
            return HttpRequestMethod.GET.name();
        }
        else if(Costanti.ID_TIPOLOGIA_HTTPS.equals(id)) {
            return SSLUtilities.getSafeDefaultProtocol();
        }
        else if(JOSECostanti.ID_ENCRYPT_KEY_ALGORITHM.equals(id) ||
                JOSECostanti.ID_ENCRYPT_CONTENT_ALGORITHM.equals(id) ||
                Costanti.ID_JWS_SIGNATURE_ALGORITHM.equals(id) ||
                Costanti.ID_JWS_ENCRYPT_KEY_ALGORITHM.equals(id) ||
                Costanti.ID_JWS_ENCRYPT_CONTENT_ALGORITHM.equals(id)) {
            SecurityProvider secProvider = new SecurityProvider();
            if(Costanti.ID_JWS_SIGNATURE_ALGORITHM.equals(id)) {
                return secProvider.getDefault(JOSECostanti.ID_SIGNATURE_ALGORITHM);
            }
            else if(Costanti.ID_JWS_ENCRYPT_KEY_ALGORITHM.equals(id) || JOSECostanti.ID_ENCRYPT_KEY_ALGORITHM.equals(id)) {
                return secProvider.getDefault(JOSECostanti.ID_ENCRYPT_KEY_ALGORITHM);
            }
            else{/**else if(Costanti.ID_JWS_ENCRYPT_CONTENT_ALGORITHM.equals(id) || JOSECostanti.ID_ENCRYPT_CONTENT_ALGORITHM.equals(id)) {*/
                return secProvider.getDefault(JOSECostanti.ID_ENCRYPT_CONTENT_ALGORITHM);
            }
        }
        return null;
    }

    @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_VALIDAZIONE_JWT_TRUSTSTORE_FILE.equals(item.getName()) ||
                Costanti.ID_VALIDAZIONE_JWT_KEYSTORE_FILE.equals(item.getName()) ||
                Costanti.ID_HTTPS_TRUSTSTORE_FILE.equals(item.getName()) ||
                Costanti.ID_HTTPS_KEYSTORE_FILE.equals(item.getName()) ||
                Costanti.ID_TOKEN_FORWARD_JWS_KEYSTORE_FILE.equals(item.getName()) ||
                Costanti.ID_TOKEN_FORWARD_JWE_KEYSTORE_FILE.equals(item.getName())) {
            
            return dynamicUpdateFile(items, mapNameValue, item, actualValue);
        }
        else if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_PASSWORD.equals(item.getName()) ||
                Costanti.ID_VALIDAZIONE_JWT_KEYSTORE_PASSWORD.equals(item.getName()) ||
                Costanti.ID_HTTPS_TRUSTSTORE_PASSWORD.equals(item.getName()) ||
                Costanti.ID_HTTPS_KEYSTORE_PASSWORD.equals(item.getName()) ||
                Costanti.ID_TOKEN_FORWARD_JWS_KEYSTORE_PASSWORD.equals(item.getName()) ||
                Costanti.ID_TOKEN_FORWARD_JWE_KEYSTORE_PASSWORD.equals(item.getName())
            ) { 
            return dynamicUpdateStorePassword(items, mapNameValue, item, actualValue);
        }
        else if(Costanti.ID_VALIDAZIONE_JWT_KEYSTORE_PASSWORD_PRIVATE_KEY.equals(item.getName()) ||
                Costanti.ID_HTTPS_KEYSTORE_PASSWORD_PRIVATE_KEY.equals(item.getName()) ||
                Costanti.ID_TOKEN_FORWARD_JWS_KEYSTORE_PASSWORD_PRIVATE_KEY.equals(item.getName()) ||
                Costanti.ID_TOKEN_FORWARD_JWE_KEYSTORE_PASSWORD_PRIVATE_KEY.equals(item.getName())
                ) {
            return dynamicUpdateStoreKeyPassword(items, mapNameValue, item, actualValue);
        }
        else if(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_OCSP_POLICY.equals(item.getName()) ||
                Costanti.ID_HTTPS_TRUSTSTORE_OCSP_POLICY.equals(item.getName())) {
            if(!this.ocspProvider.isOcspEnabled()) {
                item.setValue("");
                item.setType(ItemType.HIDDEN);
            }
            return actualValue;
        }
        else if(Costanti.ID_TOKEN_FORWARD_JWS_KEYSTORE_BYOK_POLICY.equals(item.getName()) ||
                Costanti.ID_TOKEN_FORWARD_JWE_KEYSTORE_BYOK_POLICY.equals(item.getName()) ||
                Costanti.ID_HTTPS_KEYSTORE_BYOK_POLICY.equals(item.getName()) ||
                Costanti.ID_VALIDAZIONE_JWT_KEYSTORE_BYOK_POLOCY.equals(item.getName())) {
            return dynamicUpdateByok(items, mapNameValue, item, actualValue);
        }
        else {
            return dynamicUpdateContinue1(items, mapNameValue, item, actualValue, externalResources);
        }
    }
    public String dynamicUpdateContinue1(List<?> items, Map<String, String> mapNameValue, Item item, String actualValue, ExternalResources externalResources) {
        if(Costanti.ID_DYNAMIC_DISCOVERY_CUSTOM_PARSER_PLUGIN_CHOICE.equals(item.getName())
            ) {
            return TokenUtilities.dynamicUpdateTokenPluginChoice(externalResources, TipoPlugin.TOKEN_DYNAMIC_DISCOVERY, item, actualValue);
        }
        else if(Costanti.ID_VALIDAZIONE_JWT_CUSTOM_PARSER_PLUGIN_CHOICE.equals(item.getName())
                ||
                Costanti.ID_INTROSPECTION_CUSTOM_PARSER_PLUGIN_CHOICE.equals(item.getName())
                ||
                Costanti.ID_USER_INFO_CUSTOM_PARSER_PLUGIN_CHOICE.equals(item.getName())
            ) {
            return TokenUtilities.dynamicUpdateTokenPluginChoice(externalResources, TipoPlugin.TOKEN_VALIDAZIONE, item, actualValue);
        }
        else if(Costanti.ID_DYNAMIC_DISCOVERY_CUSTOM_PARSER_PLUGIN_CLASSNAME.equals(item.getName())
            ) {
            return dynamicUpdateTokenDynamicDiscoveryPluginClassName(items, mapNameValue, item, actualValue, externalResources);
        }
        else if(Costanti.ID_VALIDAZIONE_JWT_CUSTOM_PARSER_PLUGIN_CLASSNAME.equals(item.getName()) ||
                Costanti.ID_INTROSPECTION_CUSTOM_PARSER_PLUGIN_CLASSNAME.equals(item.getName()) ||
                Costanti.ID_USER_INFO_CUSTOM_PARSER_PLUGIN_CLASSNAME.equals(item.getName())
            ) {
            return dynamicUpdateTokenPluginClassName(items, mapNameValue, item, actualValue, externalResources);
        }
        return actualValue;
    }
    private String dynamicUpdateFile(List<?> items, Map<String, String> mapNameValue, Item item, String actualValue) {
        String type = Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE;
        if(Costanti.ID_VALIDAZIONE_JWT_KEYSTORE_FILE.equals(item.getName())) {
            type = Costanti.ID_VALIDAZIONE_JWT_KEYSTORE_TYPE;
        }
        else 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;
        }
        else if(Costanti.ID_TOKEN_FORWARD_JWS_KEYSTORE_FILE.equals(item.getName())) {
            type = Costanti.ID_TOKEN_FORWARD_JWS_KEYSTORE_TYPE;
        }
        else if(Costanti.ID_TOKEN_FORWARD_JWE_KEYSTORE_FILE.equals(item.getName())) {
            type = Costanti.ID_TOKEN_FORWARD_JWE_KEYSTORE_TYPE;
        }
        
        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_VALIDAZIONE_JWT_TRUSTSTORE_TYPE;
        boolean keystore = true;
        if(Costanti.ID_VALIDAZIONE_JWT_KEYSTORE_PASSWORD.equals(item.getName())) {
            type = Costanti.ID_VALIDAZIONE_JWT_KEYSTORE_TYPE;
        }
        else if(Costanti.ID_HTTPS_TRUSTSTORE_PASSWORD.equals(item.getName())) {
            type = Costanti.ID_HTTPS_TRUSTSTORE_TYPE;
            keystore = false;
        }
        else if(Costanti.ID_HTTPS_KEYSTORE_PASSWORD.equals(item.getName())) {
            type = Costanti.ID_HTTPS_KEYSTORE_TYPE;
        }
        else if(Costanti.ID_TOKEN_FORWARD_JWS_KEYSTORE_PASSWORD.equals(item.getName())) {
            type = Costanti.ID_TOKEN_FORWARD_JWS_KEYSTORE_TYPE;
        }
        else if(Costanti.ID_TOKEN_FORWARD_JWE_KEYSTORE_PASSWORD.equals(item.getName())) {
            type = Costanti.ID_TOKEN_FORWARD_JWE_KEYSTORE_TYPE;
        }
        
        return AbstractSecurityProvider.processStorePassword(keystore, type, items, mapNameValue, item, actualValue);
    }
    private String dynamicUpdateStoreKeyPassword(List<?> items, Map<String, String> mapNameValue, Item item, String actualValue) {
        String type = Costanti.ID_VALIDAZIONE_JWT_KEYSTORE_TYPE;
        if(Costanti.ID_HTTPS_KEYSTORE_PASSWORD_PRIVATE_KEY.equals(item.getName())) {
            type = Costanti.ID_HTTPS_KEYSTORE_TYPE;
        }
        else if(Costanti.ID_TOKEN_FORWARD_JWS_KEYSTORE_PASSWORD_PRIVATE_KEY.equals(item.getName())) {
            type = Costanti.ID_TOKEN_FORWARD_JWS_KEYSTORE_TYPE;
        }
        else if(Costanti.ID_TOKEN_FORWARD_JWE_KEYSTORE_PASSWORD_PRIVATE_KEY.equals(item.getName())) {
            type = Costanti.ID_TOKEN_FORWARD_JWE_KEYSTORE_TYPE;
        }
        
        return AbstractSecurityProvider.processStoreKeyPassword(type, items, mapNameValue, item, actualValue);
    }
    private String dynamicUpdateByok(List<?> items, Map<String, String> mapNameValue, Item item, String actualValue) {
        if(!this.byokProvider.isByokEnabled()) {
            item.setValue("");
            item.setType(ItemType.HIDDEN);
            return actualValue;
        }
        else {
            return dynamicUpdateByokPolicy(items, mapNameValue, item, actualValue);
        }
    }
    private String dynamicUpdateByokPolicy(List<?> items, Map<String, String> mapNameValue, Item item, String actualValue) {
        String type = null;
        if(Costanti.ID_TOKEN_FORWARD_JWS_KEYSTORE_BYOK_POLICY.equals(item.getName())) {
            type = Costanti.ID_TOKEN_FORWARD_JWS_KEYSTORE_TYPE;
        }
        else if(Costanti.ID_TOKEN_FORWARD_JWE_KEYSTORE_BYOK_POLICY.equals(item.getName())) {
            type = Costanti.ID_TOKEN_FORWARD_JWE_KEYSTORE_TYPE;
        }
        else if(Costanti.ID_HTTPS_KEYSTORE_BYOK_POLICY.equals(item.getName())) {
            type = Costanti.ID_HTTPS_KEYSTORE_TYPE;
        }
        else if(Costanti.ID_VALIDAZIONE_JWT_KEYSTORE_BYOK_POLOCY.equals(item.getName())) {
            type = Costanti.ID_VALIDAZIONE_JWT_KEYSTORE_TYPE;
        }
        
        return AbstractSecurityProvider.processStoreByokPolicy(type, items, mapNameValue, item, actualValue);
    }
    private String dynamicUpdateTokenDynamicDiscoveryPluginClassName(List<?> items, Map<String, String> mapNameValue, Item item, String actualValue, ExternalResources externalResources) {
        String idChoice = Costanti.ID_DYNAMIC_DISCOVERY_CUSTOM_PARSER_PLUGIN_CHOICE;
        return TokenUtilities.dynamicUpdateTokenPluginClassName(externalResources, TipoPlugin.TOKEN_DYNAMIC_DISCOVERY, 
                items, mapNameValue, item, 
                idChoice, actualValue);     
    }
    private String dynamicUpdateTokenPluginClassName(List<?> items, Map<String, String> mapNameValue, Item item, String actualValue, ExternalResources externalResources) {
        String idChoice = null;
        if(Costanti.ID_VALIDAZIONE_JWT_CUSTOM_PARSER_PLUGIN_CLASSNAME.equals(item.getName())){
            idChoice = Costanti.ID_VALIDAZIONE_JWT_CUSTOM_PARSER_PLUGIN_CHOICE;
        }
        else if(Costanti.ID_INTROSPECTION_CUSTOM_PARSER_PLUGIN_CLASSNAME.equals(item.getName())){
            idChoice = Costanti.ID_INTROSPECTION_CUSTOM_PARSER_PLUGIN_CHOICE;
        }
        else {
            idChoice = Costanti.ID_USER_INFO_CUSTOM_PARSER_PLUGIN_CHOICE;
        }
        return TokenUtilities.dynamicUpdateTokenPluginClassName(externalResources, TipoPlugin.TOKEN_VALIDAZIONE, 
                items, mapNameValue, item, 
                idChoice, actualValue);     
    }

    @Override
    public ProviderInfo getProviderInfo(String id) throws ProviderException{
        if(Costanti.ID_VALIDAZIONE_JWT_CUSTOM_PARSER_PLUGIN_CLASSNAME.equals(id) ||
                Costanti.ID_INTROSPECTION_CUSTOM_PARSER_PLUGIN_CLASSNAME.equals(id) ||
                Costanti.ID_USER_INFO_CUSTOM_PARSER_PLUGIN_CLASSNAME.equals(id)) {
            ProviderInfo pInfo = new ProviderInfo();
            pInfo.setHeaderBody(DynamicHelperCostanti.PLUGIN_CLASSNAME_INFO_SINGOLA);
            pInfo.setListBody(new ArrayList<>());
            pInfo.getListBody().add(ITokenParser.class.getName());
            return pInfo;
        }
        
        return null;
    }
}