GestoreCredenzialiEngine.java

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

  22. import java.security.cert.CertStore;
  23. import java.util.List;
  24. import java.util.Map;

  26. import org.apache.commons.lang.StringUtils;
  27. import org.openspcoop2.core.config.constants.TipoAutenticazionePrincipal;
  28. import org.openspcoop2.core.constants.Costanti;
  29. import org.openspcoop2.core.id.IDSoggetto;
  30. import org.openspcoop2.message.OpenSPCoop2Message;
  31. import org.openspcoop2.message.utils.WWWAuthenticateErrorCode;
  32. import org.openspcoop2.message.utils.WWWAuthenticateGenerator;
  33. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  34. import org.openspcoop2.pdd.core.autenticazione.WWWAuthenticateConfig;
  35. import org.openspcoop2.pdd.core.connettori.InfoConnettoreIngresso;
  36. import org.openspcoop2.pdd.core.credenziali.Credenziali;
  37. import org.openspcoop2.pdd.core.credenziali.GestoreCredenzialiConfigurationException;
  38. import org.openspcoop2.pdd.core.credenziali.GestoreCredenzialiException;
  39. import org.openspcoop2.pdd.core.keystore.GestoreKeystoreCaching;
  40. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  41. import org.openspcoop2.protocol.engine.SecurityTokenUtilities;
  42. import org.openspcoop2.protocol.sdk.ChannelSecurityToken;
  43. import org.openspcoop2.protocol.sdk.Context;
  44. import org.openspcoop2.protocol.sdk.SecurityToken;
  45. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  46. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  47. import org.openspcoop2.security.keystore.cache.GestoreOCSPResource;
  48. import org.openspcoop2.security.keystore.cache.GestoreOCSPValidator;
  49. import org.openspcoop2.utils.LoggerBuffer;
  50. import org.openspcoop2.utils.certificate.Certificate;
  51. import org.openspcoop2.utils.certificate.CertificateDecodeConfig;
  52. import org.openspcoop2.utils.certificate.CertificateUtils;
  53. import org.openspcoop2.utils.certificate.KeyStore;
  54. import org.openspcoop2.utils.certificate.PrincipalType;
  55. import org.openspcoop2.utils.transport.TransportUtils;
  56. import org.openspcoop2.utils.transport.http.IOCSPValidator;

  58. /**     
  59.  * GestoreCredenzialiEngine
  60.  *
  61.  * @author Poli Andrea (poli@link.it)
  62.  * @author $Author$
  63.  * @version $Rev$, $Date$
  64.  */
  65. public class GestoreCredenzialiEngine {

  67.     private static final String KEYWORD_GATEWAY_CREDENZIALI = "@@GatewayCredenziali@@";
  68.     public static String getDBValuePrefixGatewayCredenziali(String identitaGateway, String credenzialiFornite) {
  69.         return KEYWORD_GATEWAY_CREDENZIALI+identitaGateway+"@@"+credenzialiFornite;
  70.     }
  71.     public static boolean containsPrefixGatewayCredenziali(String value) {
  72.         return value.startsWith(GestoreCredenzialiEngine.KEYWORD_GATEWAY_CREDENZIALI);
  73.     }
  74.     public static String erasePrefixGatewayCredenziali(String value) {
  75.         if(value.startsWith(GestoreCredenzialiEngine.KEYWORD_GATEWAY_CREDENZIALI)) {
  76.             String s = value.substring(GestoreCredenzialiEngine.KEYWORD_GATEWAY_CREDENZIALI.length());
  77.             if(s.contains("@@")) {
  78.                 s = s.substring(s.indexOf("@@")+2);
  79.             }
  80.             return s;
  81.         }
  82.         else {
  83.             return value;
  84.         }
  85.     }
  86.     public static String readIdentitaGatewayCredenziali(String value) {
  87.         if(value.startsWith(GestoreCredenzialiEngine.KEYWORD_GATEWAY_CREDENZIALI)) {
  88.             String s = value.substring(GestoreCredenzialiEngine.KEYWORD_GATEWAY_CREDENZIALI.length());
  89.             if(s.contains("@@")) {
  90.                 return s.substring(0,s.indexOf("@@"));
  91.             }
  92.             else {
  93.                 return null;
  94.             }
  95.         }
  96.         else {
  97.             return null;
  98.         }
  99.     }
  100.     
  101.     private String identita = null;
  102.     private boolean portaApplicativa = false;
  103.     private Context context;
  104.     private RequestInfo requestInfo;
  105.     public GestoreCredenzialiEngine(boolean portaApplicativa, Context context){
  106.         this.portaApplicativa = portaApplicativa;
  107.         this.context = context;
  108.         if(this.context!=null && this.context.containsKey(Costanti.REQUEST_INFO)) {
  109.             this.requestInfo = (RequestInfo) this.context.get(Costanti.REQUEST_INFO);
  110.         }
  111.     }

  113.     private String getPrefixMessaggioAutenticazioneFallita(String auth) {
  114.         return "Autenticazione "+auth+" del Gestore delle Credenziali '"+this.identita+ "' fallita, ";
  115.     }
  116.     private static final String NESSUN_TIPO_CREDENZIALI_TRASPORTO = "nessun tipo di credenziali (basic/ssl/principal) riscontrate nel trasporto";
  117.     private static final String CREDENZIALI_PRESENTI_TRASPORTO = "credenziali presenti nel trasporto ";
  118.     
  119.     private String getConfigurazioneNonValidaPrefix(ModalitaAutenticazioneGestoreCredenziali modalita) {
  120.         return "Configurazione del Gestore delle Credenziali non valida, con la modalità '"+modalita.getValore()+"' ";
  121.     }
  122.     private String getConfigurazioneNonValidaHeaderNonDefiniti(ModalitaAutenticazioneGestoreCredenziali modalita, String auth) {
  123.         return getConfigurazioneNonValidaPrefix(modalita)+"devono essere definiti gli header http su cui veicolare le credenziali "+auth;
  124.     }
  125.     private String getConfigurazioneNonValidaHeaderNonDefinito(ModalitaAutenticazioneGestoreCredenziali modalita, String auth) {
  126.         return getConfigurazioneNonValidaPrefix(modalita)+"deve essere definito un header http su cui veicolare le credenziali "+auth;
  127.     }
  128.     private String getConfigurazioneNonValidaAlmenoHeaderDefinito(ModalitaAutenticazioneGestoreCredenziali modalita, String auth) {
  129.         return getConfigurazioneNonValidaPrefix(modalita)+"deve essere definito almeno un header http su cui veicolare le credenziali "+auth;
  130.     }    
  131.     
  132.     private String getMessaggioHeaderHttpNonPresente(String headerName) {
  133.         return "Header HTTP '"+headerName+"' non presente";
  134.     }
  135.     
  136.     private String getSuffixNonValido(Exception e) {
  137.         return " non valido: "+e.getMessage();
  138.     }
  139.     
  140.     private String getMessaggioCertificatoPresenteHeaderNonValido(String headerName, Exception t) {
  141.         return "Certificato presente nell'header '"+headerName+"' non valido: "+t.getMessage();
  142.     }
  143.     
  144.     public Credenziali elaborazioneCredenziali(
  145.             IDSoggetto idSoggetto,
  146.             InfoConnettoreIngresso infoConnettoreIngresso, OpenSPCoop2Message messaggio)
  147.             throws GestoreCredenzialiException,
  148.             GestoreCredenzialiConfigurationException {
  149.         
  150.         if(messaggio!=null) {
  151.             // non usato
  152.         }
  153.         
  154.         Map<String, List<String>> headerTrasporto = infoConnettoreIngresso.getUrlProtocolContext().getHeaders();
  155.         
  156.         Credenziali credenzialiTrasporto = infoConnettoreIngresso.getCredenziali();
  157.         
  158.         GestoreCredenzialiConfigurazione configurazione = GestoreCredenzialiConfigurazione.getConfigurazione(!this.portaApplicativa, idSoggetto);
  159.         
  160.         // Abilitato ?
  161.         boolean enabled = (configurazione!=null) && configurazione.isEnabled();
  162.         if(!enabled) {
  163.             return credenzialiTrasporto; // credenziali originali
  164.         }
  165.         
  166.         // Identita' Gateway
  167.         this.identita=configurazione.getNome();
  168.         
  169.         // Realm
  170.         
  171.         String realm = configurazione.getRealm();
  172.         String authType = configurazione.getAuthType();
  173.         
  174.         
  175.         // AutenticazioneGateway

  177.         TipoAutenticazioneGestoreCredenziali autenticazioneGateway = configurazione.getTipoAutenticazioneCanale();
  178.         if(autenticazioneGateway==null){
  179.             throw new GestoreCredenzialiException("Tipo di autenticazione per il gestore delle credenziali non definito");
  180.         }
  181.         if(TipoAutenticazioneGestoreCredenziali.BASIC.equals(autenticazioneGateway)){
  182.             String usernameGateway = configurazione.getAutenticazioneCanaleBasicUsername();
  183.             String passwordGateway = configurazione.getAutenticazioneCanaleBasicPassword();
  184.             if(usernameGateway == null){
  185.                 throw new GestoreCredenzialiException("Richiesta autenticazione basic del gestore delle credenziali, ma username non definito");
  186.             }
  187.             if(passwordGateway == null){
  188.                 throw new GestoreCredenzialiException("Richiesta autenticazione basic del gestore delle credenziali, ma password non definito");
  189.             }
  190.             if(credenzialiTrasporto.getUsername()==null || credenzialiTrasporto.getPassword()==null){
  191.                 throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_CREDENTIALS_NOT_FOUND, 
  192.                         buildWWWProxyAuthBasic(authType, realm, true),
  193.                         getPrefixMessaggioAutenticazioneFallita(autenticazioneGateway.getValore())+"nessun tipo di credenziali basic riscontrata nel trasporto");
  194.             }
  195.             if( ! ( usernameGateway.equals(credenzialiTrasporto.getUsername()) && passwordGateway.equals(credenzialiTrasporto.getPassword()) ) ){
  196.                 String credenzialiPresenti = credenzialiTrasporto.toString();
  197.                 if(credenzialiPresenti==null || credenzialiPresenti.equals("")){
  198.                     throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_INVALID_CREDENTIALS, 
  199.                             buildWWWProxyAuthBasic(authType, realm, false),
  200.                             getPrefixMessaggioAutenticazioneFallita(autenticazioneGateway.getValore())+NESSUN_TIPO_CREDENZIALI_TRASPORTO);
  201.                 }else{
  202.                     throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_INVALID_CREDENTIALS, 
  203.                             buildWWWProxyAuthBasic(authType, realm, false),
  204.                             getPrefixMessaggioAutenticazioneFallita(autenticazioneGateway.getValore())+CREDENZIALI_PRESENTI_TRASPORTO+credenzialiPresenti);
  205.                 }
  206.             }
  207.         }
  208.         else if(TipoAutenticazioneGestoreCredenziali.SSL.equals(autenticazioneGateway)){
  209.             String subjectGateway = configurazione.getAutenticazioneCanaleSslSubject();
  210.             if(subjectGateway == null){
  211.                 throw new GestoreCredenzialiException("Richiesta autenticazione ssl del gestore delle credenziali, ma subject non definito");
  212.             }
  213.             try{
  214.                 org.openspcoop2.utils.certificate.CertificateUtils.validaPrincipal(subjectGateway, PrincipalType.SUBJECT);
  215.             }catch(Exception e){
  216.                 throw new GestoreCredenzialiException("Richiesta autenticazione ssl del gestore delle credenziali, ma subject fornito ["+subjectGateway+"] non valido: "+e.getMessage());
  217.             }
  218.             if(credenzialiTrasporto.getSubject()==null){
  219.                 throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_CREDENTIALS_NOT_FOUND, 
  220.                         buildWWWProxyAuthSSL(authType, realm, true),
  221.                         getPrefixMessaggioAutenticazioneFallita(autenticazioneGateway.getValore())+"nessun tipo di credenziali ssl riscontrata nel trasporto");
  222.             }
  223.             try{
  224.                 if( ! org.openspcoop2.utils.certificate.CertificateUtils.sslVerify(subjectGateway, credenzialiTrasporto.getSubject(), PrincipalType.SUBJECT, OpenSPCoop2Logger.getLoggerOpenSPCoopCore()) ){
  225.                     String credenzialiPresenti = credenzialiTrasporto.toString();
  226.                     if(credenzialiPresenti==null || credenzialiPresenti.equals("")){
  227.                         throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_INVALID_CREDENTIALS, 
  228.                                 buildWWWProxyAuthSSL(authType, realm, false),
  229.                                 getPrefixMessaggioAutenticazioneFallita(autenticazioneGateway.getValore())+NESSUN_TIPO_CREDENZIALI_TRASPORTO);
  230.                     }else{
  231.                         throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_INVALID_CREDENTIALS, 
  232.                                 buildWWWProxyAuthSSL(authType, realm, false),
  233.                                 getPrefixMessaggioAutenticazioneFallita(autenticazioneGateway.getValore())+CREDENZIALI_PRESENTI_TRASPORTO+credenzialiPresenti);
  234.                     }
  235.                 }
  236.             }
  237.             catch(GestoreCredenzialiConfigurationException ge) {
  238.                 throw ge;
  239.             }
  240.             catch(Exception e){
  241.                 throw new GestoreCredenzialiException("Richiesta autenticazione ssl del gateway gestore delle credenziali; errore durante la verifica: "+e.getMessage());
  242.             }
  243.         }
  244.         else if(TipoAutenticazioneGestoreCredenziali.PRINCIPAL.equals(autenticazioneGateway)){
  245.             String principalGateway = configurazione.getAutenticazioneCanalePrincipal();
  246.             if(principalGateway == null){
  247.                 throw new GestoreCredenzialiException("Richiesta autenticazione principal del gestore delle credenziali, ma principal non definito");
  248.             }
  249.             if(credenzialiTrasporto.getPrincipal()==null){
  250.                 throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_CREDENTIALS_NOT_FOUND, 
  251.                         buildWWWProxyAuthPrincipal(authType, realm, true),
  252.                         getPrefixMessaggioAutenticazioneFallita(autenticazioneGateway.getValore())+"nessun tipo di credenziale principal riscontrata nel trasporto");
  253.             }
  254.             if( ! ( principalGateway.equals(credenzialiTrasporto.getPrincipal()) ) ){
  255.                 String credenzialiPresenti = credenzialiTrasporto.toString();
  256.                 if(credenzialiPresenti==null || credenzialiPresenti.equals("")){
  257.                     throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_INVALID_CREDENTIALS, 
  258.                             buildWWWProxyAuthPrincipal(authType, realm, false),
  259.                             getPrefixMessaggioAutenticazioneFallita(autenticazioneGateway.getValore())+NESSUN_TIPO_CREDENZIALI_TRASPORTO);
  260.                 }else{
  261.                     throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_INVALID_CREDENTIALS, 
  262.                             buildWWWProxyAuthPrincipal(authType, realm, false),
  263.                             getPrefixMessaggioAutenticazioneFallita(autenticazioneGateway.getValore())+CREDENZIALI_PRESENTI_TRASPORTO+credenzialiPresenti);
  264.                 }
  265.             }
  266.         }
  267.         
  268.         
  269.         // Modalità di gestione
  270.         
  271.         ModalitaAutenticazioneGestoreCredenziali modalita = configurazione.getModalitaAutenticazioneCanale();
  272.         String modalitaAtLeastOneErrorDescription = null;
  273.         if(ModalitaAutenticazioneGestoreCredenziali.AT_LEAST_ONE.equals(modalita)) {
  274.             modalitaAtLeastOneErrorDescription = configurazione.getModalitaAutenticazioneCanaleAtLeastOneErrorDescription();
  275.         }
  276.         
  277.         
  278.         // Avvio processo di lettura credenziali portate nell'header HTTP e generate in seguito all'autenticazione effettuata dal componente Gateway
  279.         
  280.         Credenziali c = new Credenziali();  
  281.         
  282.         String headerNameBasicUsername = configurazione.getHeaderBasicUsername();
  283.         String headerNameBasicPassword = configurazione.getHeaderBasicPassword();
  284.         boolean verificaIdentitaBasic = headerNameBasicUsername!=null && headerNameBasicPassword!=null;
  285.         
  286.         String headerNameSSLSubject = configurazione.getHeaderSslSubject();
  287.         String headerNameSSLIssuer = configurazione.getHeaderSslIssuer();
  288.         String headerNameSSLCertificate = configurazione.getHeaderSslCertificate();
  289.         KeyStore trustStoreCertificatiX509 = null;
  290.         if(configurazione.getHeaderSslCertificateTrustStorePath()!=null) {
  291.             try {
  292.                 trustStoreCertificatiX509 = GestoreKeystoreCaching.getMerlinTruststore(this.requestInfo, configurazione.getHeaderSslCertificateTrustStorePath(), 
  293.                         configurazione.getHeaderSslCertificateTrustStoreType(), 
  294.                         configurazione.getHeaderSslCertificateTrustStorePassword()).getTrustStore();
  295.             }catch(Exception e){
  296.                 throw new GestoreCredenzialiException("Richiesta autenticazione ssl del gateway gestore delle credenziali; errore durante la lettura del truststore indicato ("+configurazione.getHeaderSslCertificateTrustStorePath()+"): "+e.getMessage());
  297.             }
  298.         }
  299.         boolean trustStoreCertificatiX509CheckValid = configurazione.isHeaderSslCertificateTrustStoreCheckValid();
  300.         CertStore trustStoreCertificatiX509Crls = null;
  301.         
  302.         IOCSPValidator ocspValidator = null;
  303.         if(trustStoreCertificatiX509!=null) {
  304.             boolean crlByOcsp = false;
  305.             if(configurazione.getHeaderSslCertificateOcspPolicy()!=null) {
  306.                 LoggerBuffer lb = new LoggerBuffer();
  307.                 lb.setLogDebug(OpenSPCoop2Logger.getLoggerOpenSPCoopCore());
  308.                 lb.setLogError(OpenSPCoop2Logger.getLoggerOpenSPCoopCore());
  309.                 GestoreOCSPResource ocspResourceReader = new GestoreOCSPResource(this.requestInfo);
  310.                 try {
  311.                     ocspValidator = new GestoreOCSPValidator(this.requestInfo, lb, 
  312.                             trustStoreCertificatiX509,
  313.                             configurazione.getHeaderSslCertificateCrlX509(), 
  314.                             configurazione.getHeaderSslCertificateOcspPolicy(), 
  315.                             ocspResourceReader);
  316.                 }catch(Exception e){
  317.                     throw new GestoreCredenzialiException("Richiesta autenticazione ssl del gateway gestore delle credenziali; errore durante l'inizializzazione del gestore della policy OCSP ("+configurazione.getHeaderSslCertificateOcspPolicy()+"): "+e.getMessage());
  318.                 }
  319.                 if(ocspValidator!=null) {
  320.                     GestoreOCSPValidator gOcspValidator = (GestoreOCSPValidator) ocspValidator;
  321.                     if(gOcspValidator.getOcspConfig()!=null) {
  322.                         crlByOcsp = gOcspValidator.getOcspConfig().isCrl();
  323.                     }
  324.                 }
  325.             }
  326.             if(configurazione.getHeaderSslCertificateCrlX509()!=null && !crlByOcsp) {
  327.                 try {
  328.                     trustStoreCertificatiX509Crls = GestoreKeystoreCaching.getCRLCertstore(this.requestInfo, configurazione.getHeaderSslCertificateCrlX509()).getCertStore();
  329.                 }catch(Exception e){
  330.                     throw new GestoreCredenzialiException("Richiesta autenticazione ssl del gateway gestore delle credenziali; errore durante la lettura delle CRLs ("+configurazione.getHeaderSslCertificateCrlX509()+"): "+e.getMessage());
  331.                 }
  332.             }
  333.         }
  334.         boolean sslCertificateUrlDecode = false;
  335.         boolean sslCertificateBase64Decode = false;
  336.         boolean sslCertificateHexDecode = false;
  337.         boolean sslCertificateUrlDecodeOrBase64Decode = false;
  338.         boolean sslCertificateUrlDecodeOrBase64DecodeOrHexDecode = false;
  339.         boolean sslCertificateEnrichBeginEnd = false;
  340.         boolean sslCertificateReplace = false;
  341.         String sslCertificateReplaceSource = null;
  342.         String sslCertificateReplaceDest = null;
  343.         String sslCertificateNoneOption = null;
  344.         boolean sslCertificateIgnoreEmpty = false;
  345.         if(headerNameSSLCertificate!=null) {
  346.             sslCertificateUrlDecode = configurazione.isHeaderSslCertificateUrlDecode();
  347.             sslCertificateBase64Decode = configurazione.isHeaderSslCertificateBase64Decode();
  348.             sslCertificateHexDecode = configurazione.isHeaderSslCertificateHexDecode();
  349.             sslCertificateUrlDecodeOrBase64Decode = configurazione.isHeaderSslCertificateUrlDecodeOrBase64Decode();
  350.             sslCertificateUrlDecodeOrBase64DecodeOrHexDecode = configurazione.isHeaderSslCertificateUrlDecodeOrBase64DecodeOrHexDecode();
  351.             sslCertificateEnrichBeginEnd = configurazione.isHeaderSslCertificateEnrichBeginEnd();
  352.             sslCertificateReplace = configurazione.isHeaderSslCertificateReplaceCharacters();
  353.             if(sslCertificateReplace) {
  354.                 sslCertificateReplaceSource = configurazione.getHeaderSslCertificateReplaceCharactersSource();
  355.                 sslCertificateReplaceDest = configurazione.getHeaderSslCertificateReplaceCharactersDest();
  356.             }
  357.             sslCertificateNoneOption = configurazione.getHeaderSslCertificateNoneOption();
  358.             sslCertificateIgnoreEmpty = configurazione.isHeaderSslCertificateIgnoreEmpty();
  359.         }
  360.         boolean verificaIdentitaSSL = headerNameSSLSubject!=null || headerNameSSLCertificate!=null;
  361.         
  362.         String headerNamePrincipal = configurazione.getHeaderPrincipal();
  363.         boolean verificaIdentitaPrincipal = headerNamePrincipal!=null;
  364.         
  365.         if(!verificaIdentitaBasic && !verificaIdentitaSSL && !verificaIdentitaPrincipal){
  366.             return credenzialiTrasporto; // credenziali originali
  367.         }
  368.         
  369.         boolean existsHeaderBasicUsername = false;
  370.         boolean existsHeaderBasicPassword = false;
  371.         if(verificaIdentitaBasic){
  372.             existsHeaderBasicUsername = existsHeader(headerTrasporto, headerNameBasicUsername);
  373.             existsHeaderBasicPassword = existsHeader(headerTrasporto, headerNameBasicPassword);
  374.         }
  375.         boolean existsHeaderSslSubject = false;
  376.         boolean existsHeaderSslIssuer = false;
  377.         boolean existsHeaderSslCertificate = false;
  378.         if(verificaIdentitaSSL){
  379.             existsHeaderSslSubject = existsHeader(headerTrasporto, headerNameSSLSubject);
  380.             existsHeaderSslIssuer = existsHeader(headerTrasporto, headerNameSSLIssuer);
  381.             existsHeaderSslCertificate = existsHeader(headerTrasporto, headerNameSSLCertificate);
  382.         }
  383.         boolean existsHeaderPrincipal = false;
  384.         if(verificaIdentitaPrincipal){
  385.             existsHeaderPrincipal = existsHeader(headerTrasporto, headerNamePrincipal);
  386.         }
  387.         
  388.         
  389.         // Interpretazione della modalità richiesta di gestione
  390.         // Il Gestore può funzionare in modalità 'none' e quindi le richieste in arrivo possono anche non presentare alcun header che veicola le credenziali. 
  391.         // L'unico vincolo è che se vi sono delle credenziali devono essere valide (non vuote e corrette per ssl).
  392.         // Il Gestore può inoltre essere configurato per richiedere almeno una credenziale o esattamente una credenziale di un certo tipo.
  393.         // Con la modalità 'none' o 'atLeastOne' è possibile usare il gestore davanti a erogazioni/fruizioni con tipi di autenticazione differenti, 
  394.         // delegando poi alla singola erogazione o fruizione il controllo che le credenziali siano effetivamente presenti
  395.         switch (modalita) {
  396.         case NONE:
  397.             if( (!existsHeaderBasicUsername || !existsHeaderBasicPassword) && !existsHeaderSslSubject && !existsHeaderSslCertificate && !existsHeaderPrincipal ){
  398.                 return credenzialiTrasporto; // credenziali originali poiche' non sono presenti header che indicano nuove credenziali.  
  399.             }
  400.             break;
  401.         case AT_LEAST_ONE:
  402.             if( (!existsHeaderBasicUsername || !existsHeaderBasicPassword) && !existsHeaderSslSubject && !existsHeaderSslCertificate && !existsHeaderPrincipal ){
  403.                 StringBuilder sb = new StringBuilder();
  404.                 if(headerNameBasicUsername!=null) {
  405.                     sb.append(headerNameBasicUsername);
  406.                 }
  407.                 if(headerNameSSLSubject!=null) {
  408.                     if(sb.length()>0) {
  409.                         sb.append(",");
  410.                     }
  411.                     sb.append(headerNameSSLSubject);
  412.                 }
  413.                 if(headerNameSSLCertificate!=null) {
  414.                     if(sb.length()>0) {
  415.                         sb.append(",");
  416.                     }
  417.                     sb.append(headerNameSSLCertificate);
  418.                 }
  419.                 if(headerNamePrincipal!=null) {
  420.                     if(sb.length()>0) {
  421.                         sb.append(",");
  422.                     }
  423.                     sb.append(headerNamePrincipal);
  424.                 }
  425.                 throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_FORWARDED_CREDENTIALS_NOT_FOUND, 
  426.                         buildWWWProxyAuthAtleastOne(authType, realm,
  427.                                 modalitaAtLeastOneErrorDescription),
  428.                         "Non sono presenti Header HTTP che veicolano credenziali (header non rilevati: "+sb.toString()+")");
  429.             }
  430.             break;
  431.         case BASIC:
  432.             if(!verificaIdentitaBasic){
  433.                 throw new GestoreCredenzialiException(getConfigurazioneNonValidaHeaderNonDefiniti(modalita, modalita.getValore()));
  434.             }
  435.             if( !existsHeaderBasicUsername ) {
  436.                 throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_FORWARDED_CREDENTIALS_NOT_FOUND, 
  437.                         buildWWWAuthBasic(),
  438.                         getMessaggioHeaderHttpNonPresente(headerNameBasicUsername));
  439.             }
  440.             if( !existsHeaderBasicPassword ) {
  441.                 throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_FORWARDED_CREDENTIALS_NOT_FOUND, 
  442.                         buildWWWAuthBasic(),
  443.                         getMessaggioHeaderHttpNonPresente(headerNameBasicPassword));
  444.             }
  445.             // il controllo che il valore presente negli header non sia vuoto viene fatto dopo.
  446.             break;
  447.         case SSL:
  448.             if(!verificaIdentitaSSL){
  449.                 throw new GestoreCredenzialiException(getConfigurazioneNonValidaAlmenoHeaderDefinito(modalita, modalita.getValore()));
  450.             }
  451.             if(headerNameSSLSubject!=null && headerNameSSLCertificate!=null) {
  452.                 if(!existsHeaderSslSubject && !existsHeaderSslCertificate) {
  453.                     throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_FORWARDED_CREDENTIALS_NOT_FOUND, 
  454.                             buildWWWAuthSSL(),
  455.                             "Header HTTP '"+headerNameSSLSubject+"' o '"+headerNameSSLCertificate+"' non presente");
  456.                 }
  457.             }
  458.             else if( headerNameSSLSubject!=null) {
  459.                 if(!existsHeaderSslSubject) {
  460.                     throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_FORWARDED_CREDENTIALS_NOT_FOUND, 
  461.                             buildWWWAuthSSL(),
  462.                             getMessaggioHeaderHttpNonPresente(headerNameSSLSubject));
  463.                 }
  464.             }
  465.             else { /** per forza questo caso if( headerNameSSLCertificate!=null */
  466.                 if( !existsHeaderSslCertificate) {
  467.                     throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_FORWARDED_CREDENTIALS_NOT_FOUND, 
  468.                             buildWWWAuthSSL(),
  469.                             getMessaggioHeaderHttpNonPresente(headerNameSSLCertificate));
  470.                 }
  471.             }
  472.             // il controllo che il valore presente negli header non sia vuoto e/o corretto viene fatto dopo.
  473.             break;
  474.         case PRINCIPAL:
  475.             if(!verificaIdentitaPrincipal){
  476.                 throw new GestoreCredenzialiException(getConfigurazioneNonValidaHeaderNonDefinito(modalita, modalita.getValore()));
  477.             }
  478.             if( !existsHeaderPrincipal) {
  479.                 throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_FORWARDED_CREDENTIALS_NOT_FOUND, 
  480.                         buildWWWAuthPrincipal(),
  481.                         getMessaggioHeaderHttpNonPresente(headerNamePrincipal));
  482.             }
  483.             // il controllo che il valore presente negli header non sia vuoto viene fatto dopo.
  484.             break;
  485.         default:
  486.             break;
  487.         }
  488.         

  490.                 
  491.         // Lettura credenziali Basic
  492.         if(verificaIdentitaBasic &&
  493.                 existsHeaderBasicUsername &&
  494.                 existsHeaderBasicPassword ){
  495.             
  496.             String username = getProperty(headerTrasporto,  headerNameBasicUsername );
  497.             String password = getProperty(headerTrasporto,  headerNameBasicPassword );
  498.             if(username==null || "".equals(username)){
  499.                 throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_FORWARDED_CREDENTIALS_NOT_FOUND, 
  500.                         buildWWWAuthBasic(),
  501.                         "Username value non fornito nell'header del trasporto "+headerNameBasicUsername);
  502.             }
  503.             if(password==null || "".equals(password)){
  504.                 throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_FORWARDED_CREDENTIALS_NOT_FOUND, 
  505.                         buildWWWAuthBasic(),
  506.                         "Password value non fornito nell'header del trasporto "+headerNameBasicPassword);
  507.             }
  508.             c.setUsername(username);
  509.             c.setPassword(password);
  510.         }
  511.         
  512.         // Lettura credenziali ssl
  513.         if(verificaIdentitaSSL) {
  514.             if(existsHeaderSslSubject ){
  515.                 
  516.                 String subject = getProperty(headerTrasporto,   headerNameSSLSubject );
  517.                 if(subject==null || "".equals(subject)){
  518.                     throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_FORWARDED_CREDENTIALS_NOT_FOUND, 
  519.                             buildWWWAuthSSL(),
  520.                             "Subject value non fornito nell'header del trasporto "+headerNameSSLSubject);
  521.                 }
  522.                 try{
  523.                     org.openspcoop2.utils.certificate.CertificateUtils.formatPrincipal(subject, PrincipalType.SUBJECT);
  524.                     /** Non posso validare, verra' fornito un certificato nel formato RFC 2253 o RFC 1779
  525.                     Sicuramente puo' contenere sia il carattere '/' che ',' ma uno dei due sara' escaped tramite il formato richiesto.
  526.                     org.openspcoop.utils.Utilities.validaSubject(subject);*/
  527.                 }catch(Exception e){
  528.                     throw new GestoreCredenzialiException("Subject value fornito nell'header del trasporto "+headerNameSSLSubject+getSuffixNonValido(e),e);
  529.                 }
  530.                 c.setSubject(subject);
  531.             }
  532.             if(existsHeaderSslIssuer ){
  533.                 
  534.                 String issuer = getProperty(headerTrasporto,    headerNameSSLIssuer );
  535.                 if(issuer==null || "".equals(issuer)){
  536.                     throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_FORWARDED_CREDENTIALS_NOT_FOUND, 
  537.                             buildWWWAuthSSL(),
  538.                             "Issuer value non fornito nell'header del trasporto "+headerNameSSLIssuer);
  539.                 }
  540.                 try{
  541.                     org.openspcoop2.utils.certificate.CertificateUtils.formatPrincipal(issuer, PrincipalType.ISSUER);
  542.                     /**Non posso validare, verra' fornito un certificato nel formato RFC 2253 o RFC 1779
  543.                     Sicuramente puo' contenere sia il carattere '/' che ',' ma uno dei due sara' escaped tramite il formato richiesto.
  544.                     org.openspcoop.utils.Utilities.validaSubject(subject);*/
  545.                 }catch(Exception e){
  546.                     throw new GestoreCredenzialiException("Issuer value fornito nell'header del trasporto "+headerNameSSLIssuer+getSuffixNonValido(e),e);
  547.                 }
  548.                 c.setIssuer(issuer);
  549.             }
  550.             if(existsHeaderSslCertificate ){
  551.                 
  552.                 String certificate = getProperty(headerTrasporto,   headerNameSSLCertificate );
  553.                 
  554.                 if(certificate!=null &&
  555.                         (
  556.                                 (sslCertificateNoneOption!=null && sslCertificateNoneOption.equals(certificate))
  557.                                 ||
  558.                                 (StringUtils.isEmpty(certificate) && sslCertificateIgnoreEmpty)
  559.                         )
  560.                     ){
  561.                     c.setCertificate(null);
  562.                     c.setSubject(null);
  563.                     c.setIssuer(null);
  564.                     SecurityToken securityToken = SecurityTokenUtilities.readSecurityToken(this.context);
  565.                     if(securityToken!=null) {
  566.                         securityToken.setChannel(null); // sovrascrivo eventuali esistente
  567.                     }
  568.                 }
  569.                 else {
  570.                 
  571.                     if(certificate==null || "".equals(certificate)){
  572.                         throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_FORWARDED_CREDENTIALS_NOT_FOUND, 
  573.                                 buildWWWAuthSSL(),
  574.                                 "Certificate non fornito nell'header del trasporto "+headerNameSSLCertificate);
  575.                     }
  576.                     
  577.                                     
  578.                     CertificateDecodeConfig config = new CertificateDecodeConfig();
  579.                     config.setUrlDecode(sslCertificateUrlDecode);
  580.                     config.setBase64Decode(sslCertificateBase64Decode);
  581.                     config.setHexDecode(sslCertificateHexDecode);
  582.                     config.setUrlDecodeOrBase64Decode(sslCertificateUrlDecodeOrBase64Decode);
  583.                     config.setUrlDecodeOrBase64DecodeOrHexDecode(sslCertificateUrlDecodeOrBase64DecodeOrHexDecode);
  584.                     config.setEnrichPEMBeginEnd(sslCertificateEnrichBeginEnd);
  585.                     config.setReplace(sslCertificateReplace);
  586.                     if(sslCertificateReplace) {
  587.                         if(sslCertificateReplaceSource!=null && !StringUtils.isEmpty(sslCertificateReplaceSource)) {
  588.                             config.setReplaceSource(sslCertificateReplaceSource);
  589.                         }
  590.                         if(sslCertificateReplaceDest!=null && !StringUtils.isEmpty(sslCertificateReplaceDest)) {
  591.                             config.setReplaceDest(sslCertificateReplaceDest);
  592.                         }
  593.                     }
  594.     
  595.                     Certificate cer = null;
  596.                     try{
  597.                         cer = CertificateUtils.readCertificate(config, certificate);                    
  598.                         c.setCertificate(cer);
  599.                         
  600.                         String subject = c.getCertificate().getCertificate().getSubject().toString();
  601.                         String issuer = c.getCertificate().getCertificate().getIssuer().toString();
  602.                         c.setSubject(subject);
  603.                         c.setIssuer(issuer);
  604.                         
  605.                     }catch(Exception e){
  606.                         throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_FORWARDED_CREDENTIALS_NOT_FOUND, 
  607.                                 buildWWWAuthSSL(),
  608.                                 "Certificate fornito nell'header del trasporto "+headerNameSSLCertificate+getSuffixNonValido(e), e);
  609.                     }
  610.                     
  611.                     if(cer!=null && trustStoreCertificatiX509!=null) {
  612.                         if(!cer.getCertificate().isVerified(trustStoreCertificatiX509, true)) {
  613.                             throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_FORWARDED_CREDENTIALS_NOT_FOUND, 
  614.                                     buildWWWAuthSSL(),
  615.                                     "Certificato presente nell'header '"+headerNameSSLCertificate+"' non è verificabile rispetto alle CA conosciute");
  616.                         }
  617.                         if(trustStoreCertificatiX509Crls!=null) {
  618.                             try {
  619.                                 cer.getCertificate().checkValid(trustStoreCertificatiX509Crls, trustStoreCertificatiX509);
  620.                             }catch(Exception t) {
  621.                                 throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_FORWARDED_CREDENTIALS_NOT_FOUND, 
  622.                                         buildWWWAuthSSL(),
  623.                                         getMessaggioCertificatoPresenteHeaderNonValido(headerNameSSLCertificate,t));
  624.                             }
  625.                         }
  626.                         else if(trustStoreCertificatiX509CheckValid){
  627.                             try {
  628.                                 cer.getCertificate().checkValid();
  629.                             }catch(Exception t) {
  630.                                 throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_FORWARDED_CREDENTIALS_NOT_FOUND, 
  631.                                         buildWWWAuthSSL(),
  632.                                         getMessaggioCertificatoPresenteHeaderNonValido(headerNameSSLCertificate,t));
  633.                             }
  634.                         }
  635.                         if(ocspValidator!=null) {
  636.                             try {
  637.                                 ocspValidator.valid(cer.getCertificate().getCertificate());
  638.                             }catch(Exception t) {
  639.                                 throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_FORWARDED_CREDENTIALS_NOT_FOUND, 
  640.                                         buildWWWAuthSSL(),
  641.                                         getMessaggioCertificatoPresenteHeaderNonValido(headerNameSSLCertificate,t));
  642.                             }
  643.                         }
  644.                     }
  645.                     
  646.                     /* --------------- SecurityToken --------------- */
  647.                     try {
  648.                         if(cer!=null && this.context!=null) {
  649.                             SecurityToken securityToken = SecurityTokenUtilities.newSecurityToken(this.context);
  650.                             ChannelSecurityToken channelSecurityToken = new ChannelSecurityToken();
  651.                             channelSecurityToken.setCertificate(cer.getCertificate());
  652.                             securityToken.setChannel(channelSecurityToken); // sovrascrivo eventuali esistente
  653.                         }
  654.                     }catch(Exception e){
  655.                         throw new GestoreCredenzialiException("Costruzione SecurityToken non riuscita: "+e.getMessage(),e);
  656.                     }
  657.                 }
  658.             }
  659.         }
  660.         
  661.         // Lettura credenziali principal
  662.         if(verificaIdentitaPrincipal &&
  663.                 existsHeaderPrincipal ){
  664.             
  665.             String principal = getProperty(headerTrasporto,     headerNamePrincipal );
  666.             if(principal==null || "".equals(principal)){
  667.                 throw new GestoreCredenzialiConfigurationException(IntegrationFunctionError.PROXY_AUTHENTICATION_FORWARDED_CREDENTIALS_NOT_FOUND, 
  668.                         buildWWWAuthPrincipal(),
  669.                         "Principal value non fornito nell'header del trasporto "+headerNamePrincipal);
  670.             }
  671.             c.setPrincipal(principal);
  672.         }
  673.         
  674.         return c;
  675.         
  676.     }
  677.     
  678.     public String getIdentitaGestoreCredenziali(){
  679.         return this.identita;
  680.     }
  681.     
  682.     private boolean existsHeader(Map<String, List<String>> properties, String name){
  683.         if(properties!=null){
  684.             return TransportUtils.containsKey(properties, name);
  685.         }else{
  686.             return false;
  687.         }
  688.     }
  689.     
  690.     private String getProperty(Map<String, List<String>> properties, String name){
  691.         if(properties!=null){
  692.             return TransportUtils.getFirstValue(properties, name);
  693.         }else{
  694.             return null;
  695.         }
  696.         
  697.     }
  698.     
  699.     public static String buildWWWProxyAuthBasic(String authType, String realm, boolean missing) {
  700.         if(realm==null || "".equals(realm) || authType==null || "".equals(authType)) {
  701.             return null;
  702.         }
  703.         WWWAuthenticateConfig configGW = OpenSPCoop2Properties.getInstance().getRealmAutenticazioneBasicWWWAuthenticateConfig();
  704.         WWWAuthenticateConfig proxy = configGW!=null ? (WWWAuthenticateConfig) configGW.clone() : new WWWAuthenticateConfig();
  705.         proxy.setRealm(realm);
  706.         proxy.setAuthType(authType);
  707.         return missing ? proxy.buildWWWAuthenticateHeaderValue_notFound() : proxy.buildWWWAuthenticateHeaderValue_invalid();
  708.     }
  709.     public static String buildWWWProxyAuthSSL(String authType, String realm, boolean missing) {
  710.         if(realm==null || "".equals(realm) || authType==null || "".equals(authType)) {
  711.             return null;
  712.         }
  713.         WWWAuthenticateConfig configGW = OpenSPCoop2Properties.getInstance().getRealmAutenticazioneHttpsWWWAuthenticateConfig();
  714.         WWWAuthenticateConfig proxy = configGW!=null ? (WWWAuthenticateConfig) configGW.clone() : new WWWAuthenticateConfig();
  715.         proxy.setRealm(realm);
  716.         proxy.setAuthType(authType);
  717.         return missing ? proxy.buildWWWAuthenticateHeaderValue_notFound() : proxy.buildWWWAuthenticateHeaderValue_invalid();
  718.     }
  719.     public static String buildWWWProxyAuthPrincipal(String authType, String realm, boolean missing) {
  720.         if(realm==null || "".equals(realm) || authType==null || "".equals(authType)) {
  721.             return null;
  722.         }
  723.         WWWAuthenticateConfig configGW = OpenSPCoop2Properties.getInstance().getRealmAutenticazionePrincipalWWWAuthenticateConfig(TipoAutenticazionePrincipal.CONTAINER);
  724.         WWWAuthenticateConfig proxy = configGW!=null ? (WWWAuthenticateConfig) configGW.clone() : new WWWAuthenticateConfig();
  725.         proxy.setRealm(realm);
  726.         proxy.setAuthType(authType);
  727.         return missing ? proxy.buildWWWAuthenticateHeaderValue_notFound() : proxy.buildWWWAuthenticateHeaderValue_invalid();
  728.     }
  729.     public static String buildWWWProxyAuthAtleastOne(String authType, String realm, String errorDescription) {
  730.         if(realm==null || "".equals(realm) || authType==null || "".equals(authType)) {
  731.             return null;
  732.         }
  733.         if(errorDescription!=null && !"".equals(errorDescription)) {
  734.             return WWWAuthenticateGenerator.buildCustomHeaderValue(authType, realm, WWWAuthenticateErrorCode.invalid_request, 
  735.                     errorDescription);
  736.         }
  737.         else {
  738.             WWWAuthenticateErrorCode errorCode = null;
  739.             return WWWAuthenticateGenerator.buildCustomHeaderValue(authType, realm, errorCode, null);
  740.         }
  741.     }

  743.     
  744.     public static String buildWWWAuthBasic() {
  745.         WWWAuthenticateConfig config = OpenSPCoop2Properties.getInstance().getRealmAutenticazioneBasicWWWAuthenticateConfig();
  746.         if(config!=null) {
  747.             return config.buildWWWAuthenticateHeaderValue_notFound();
  748.         }
  749.         return null;
  750.     }
  751.     public static String buildWWWAuthSSL() {
  752.         WWWAuthenticateConfig config = OpenSPCoop2Properties.getInstance().getRealmAutenticazioneHttpsWWWAuthenticateConfig();
  753.         if(config!=null) {
  754.             return config.buildWWWAuthenticateHeaderValue_notFound();
  755.         }
  756.         return null;
  757.     }
  758.     public static String buildWWWAuthPrincipal() {
  759.         WWWAuthenticateConfig config = OpenSPCoop2Properties.getInstance().getRealmAutenticazionePrincipalWWWAuthenticateConfig(TipoAutenticazionePrincipal.CONTAINER);
  760.         if(config!=null) {
  761.             return config.buildWWWAuthenticateHeaderValue_notFound();
  762.         }
  763.         return null;
  764.     }
  765. }
Created with JaCoCo 0.8.8.202204050719