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



  23. package org.openspcoop2.pdd.core.autenticazione.pd;

  25. import org.openspcoop2.core.config.constants.TipoAutenticazionePrincipal;
  26. import org.openspcoop2.core.id.IDServizioApplicativo;
  27. import org.openspcoop2.core.id.IDSoggetto;
  28. import org.openspcoop2.core.transazioni.utils.TipoCredenzialeMittente;
  29. import org.openspcoop2.message.OpenSPCoop2Message;
  30. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  31. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  32. import org.openspcoop2.pdd.core.autenticazione.AutenticazioneException;
  33. import org.openspcoop2.pdd.core.autenticazione.AutenticazioneUtils;
  34. import org.openspcoop2.pdd.core.autenticazione.ParametriAutenticazione;
  35. import org.openspcoop2.pdd.core.autenticazione.ParametriAutenticazionePrincipal;
  36. import org.openspcoop2.pdd.core.autenticazione.PrincipalUtilities;
  37. import org.openspcoop2.pdd.core.autenticazione.WWWAuthenticateConfig;
  38. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  39. import org.openspcoop2.protocol.sdk.constants.CodiceErroreIntegrazione;
  40. import org.openspcoop2.protocol.sdk.constants.CostantiProtocollo;
  41. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  42. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  43. import org.openspcoop2.utils.BooleanNullable;

  45. /**
  46.  * Classe che implementa una autenticazione BASIC.
  47.  *
  48.  * @author Andrea Poli (apoli@link.it)
  49.  * @author $Author$
  50.  * @version $Rev$, $Date$
  51.  */

  53. public class AutenticazionePrincipal extends AbstractAutenticazioneBase {

  55.     private TipoAutenticazionePrincipal tipoAutenticazionePrincipal = TipoAutenticazionePrincipal.CONTAINER;
  56.     private String nome = null;
  57.     private String pattern = null;
  58.     private TipoCredenzialeMittente tipoTokenClaim = null; // uso trasporto come custom
  59.     private boolean cleanPrincipal = true;
  60.     
  61.     private boolean logError = true;
  62.     @Override
  63.     public void setLogError(boolean logError) {
  64.         this.logError = logError;
  65.     }

  67.     @Override
  68.     public void initParametri(ParametriAutenticazione parametri) throws AutenticazioneException {
  69.         super.initParametri(parametri);

  71.         ParametriAutenticazionePrincipal authPrincipal = new ParametriAutenticazionePrincipal(this.parametri);
  72.         if(authPrincipal.getTipoAutenticazione()!=null) {
  73.             this.tipoAutenticazionePrincipal = authPrincipal.getTipoAutenticazione();
  74.             
  75.             switch (this.tipoAutenticazionePrincipal) {
  76.             case CONTAINER:
  77.             case INDIRIZZO_IP:
  78.             case INDIRIZZO_IP_X_FORWARDED_FOR:
  79.                 break;
  80.             case HEADER:
  81.                 this.nome = authPrincipal.getNome();
  82.                 if(this.nome==null) {
  83.                     throw new AutenticazioneException("Nome dell'header, da cui estrarre il principal, non indicato");
  84.                 }
  85.                 break;
  86.             case FORM:
  87.                 this.nome = authPrincipal.getNome();
  88.                 if(this.nome==null) {
  89.                     throw new AutenticazioneException("Nome del parametro della query, da cui estrarre il principal, non indicato");
  90.                 }
  91.                 break;
  92.             case URL:
  93.                 this.pattern = authPrincipal.getPattern();
  94.                 if(this.pattern==null) {
  95.                     throw new AutenticazioneException("Espressione Regolare, da utilizzare sulla url per estrarre il principal, non indicata");
  96.                 }
  97.                 break;
  98.             // Ho levato il contenuto, poichè senno devo fare il digest per poterlo poi cachare
  99. /**             case CONTENT:
  100. //                  this.pattern = authPrincipal.getPattern();
  101. //                  if(this.pattern==null) {
  102. //                      throw new AutenticazioneException("Pattern, da utilizzare per estrarre dal contenuto il principal, non indicato");
  103. //                  }
  104. //                  break;*/
  105.             case TOKEN:
  106.                 this.tipoTokenClaim = authPrincipal.getTokenClaim();
  107.                 if(this.tipoTokenClaim==null) {
  108.                     throw new AutenticazioneException("Token Claim, da cui estrarre il principal, non indicato");
  109.                 }
  110.                 if(TipoCredenzialeMittente.TRASPORTO.equals(this.tipoTokenClaim)) {
  111.                     this.nome = authPrincipal.getNome();
  112.                     if(this.nome==null) {
  113.                         throw new AutenticazioneException("Nome del token claim, da cui estrarre il principal, non indicato");
  114.                     }
  115.                 }
  116.                 break;
  117.             }
  118.             
  119.             BooleanNullable cleanNullable = authPrincipal.getCleanPrincipal();
  120.             if(cleanNullable!=null && cleanNullable.getValue()!=null) {
  121.                 this.cleanPrincipal = cleanNullable.getValue();
  122.             }
  123.         }
  124.         
  125.     }
  126.     
  127.     @Override
  128.     public String getSuffixKeyAuthenticationResultInCache(DatiInvocazionePortaDelegata datiInvocazione) {
  129.         switch (this.tipoAutenticazionePrincipal) {
  130.         case CONTAINER:
  131.             return null;
  132.         case HEADER:
  133.         case FORM:
  134.         case URL:
  135.         case INDIRIZZO_IP:
  136.         case INDIRIZZO_IP_X_FORWARDED_FOR:
  137.         case TOKEN:
  138.             if(datiInvocazione==null) {
  139.                 return null;
  140.             }
  141.             try {
  142.                 return PrincipalUtilities.getPrincipal(this.tipoAutenticazionePrincipal, this.nome, this.pattern, this.tipoTokenClaim, 
  143.                         datiInvocazione.getInfoConnettoreIngresso(), this.getPddContext(), false,
  144.                         new StringBuilder());
  145.             }catch(Exception e) {
  146.                 return null;
  147.             }
  148.         // Ho levato il contenuto, poichè senno devo fare il digest per poterlo poi cachare
  149. /**     case CONTENT:*/
  150.         }
  151.         return null;
  152.     }
  153.     
  154.     @Override
  155.     public EsitoAutenticazionePortaDelegata process(DatiInvocazionePortaDelegata datiInvocazione) throws AutenticazioneException{

  157.         EsitoAutenticazionePortaDelegata esito = new EsitoAutenticazionePortaDelegata();
  158.         
  159.         if(datiInvocazione==null) {
  160.             throw new AutenticazioneException("Param datiInvocazione is null");
  161.         }
  162.         
  163.         OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  164.         WWWAuthenticateConfig wwwAuthenticateConfig = op2Properties.getRealmAutenticazionePrincipalWWWAuthenticateConfig(this.tipoAutenticazionePrincipal);
  165.         
  166.         IDSoggetto soggettoFruitore = null;
  167.         if(datiInvocazione.getPd()!=null) {
  168.             soggettoFruitore = new IDSoggetto(datiInvocazione.getPd().getTipoSoggettoProprietario(), datiInvocazione.getPd().getNomeSoggettoProprietario());
  169.         }
  170.         
  171.         StringBuilder fullCredential= new StringBuilder();
  172.         
  173.         // Controllo credenziali fornite
  174.         String principal = null;
  175.         try {
  176.             principal = PrincipalUtilities.getPrincipal(this.tipoAutenticazionePrincipal, this.nome, this.pattern, this.tipoTokenClaim,  
  177.                     datiInvocazione.getInfoConnettoreIngresso(), this.getPddContext(), true,
  178.                     fullCredential);
  179.         }catch(Exception e) {
  180.             if(this.logError) {
  181.                 OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("AutenticazionePrincipal non riuscita",e);
  182.             }
  183.             esito.setErroreIntegrazione(IntegrationFunctionError.AUTHENTICATION_CREDENTIALS_NOT_FOUND, ErroriIntegrazione.ERRORE_402_AUTENTICAZIONE_FALLITA.getErrore402_AutenticazioneFallitaPrincipal(CostantiProtocollo.CREDENZIALI_NON_FORNITE,principal));
  184.             esito.setClientAuthenticated(false);
  185.             esito.setClientIdentified(false);
  186.             if(wwwAuthenticateConfig!=null) {
  187.                 esito.setWwwAuthenticateErrorHeader(wwwAuthenticateConfig.buildWWWAuthenticateHeaderValue_notFound());
  188.             }
  189.             return esito;
  190.         }
  191.         if( principal==null || "".equals(principal) ){
  192.             esito.setErroreIntegrazione(IntegrationFunctionError.AUTHENTICATION_CREDENTIALS_NOT_FOUND, ErroriIntegrazione.ERRORE_402_AUTENTICAZIONE_FALLITA.getErrore402_AutenticazioneFallitaPrincipal(CostantiProtocollo.CREDENZIALI_NON_FORNITE,principal));
  193.             esito.setClientAuthenticated(false);
  194.             esito.setClientIdentified(false);
  195.             if(wwwAuthenticateConfig!=null) {
  196.                 esito.setWwwAuthenticateErrorHeader(wwwAuthenticateConfig.buildWWWAuthenticateHeaderValue_notFound());
  197.             }
  198.             return esito;
  199.         }
  200.         
  201.         // per conoscere la credenziale passata anche in caso di autenticazione fallita
  202.         esito.setFullCredential(fullCredential.toString());
  203.         
  204.         // Essendoci il principal del chiamante, il client e' stato autenticato dal container
  205.         esito.setClientAuthenticated(true);
  206.         esito.setCredential(principal);
  207.         esito.setEnrichPrincipal(true);
  208.         
  209.         IDServizioApplicativo idServizioApplicativo = null;
  210.         try{
  211.             idServizioApplicativo = ConfigurazionePdDManager.getInstance(datiInvocazione.getState()).
  212.                         getIdServizioApplicativoByCredenzialiPrincipal(principal);
  213.             if(idServizioApplicativo!=null && soggettoFruitore==null) {
  214.                 soggettoFruitore = idServizioApplicativo.getIdSoggettoProprietario();
  215.             }
  216.         }catch(Exception e){
  217.             if(this.logError) {
  218.                 OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("AutenticazionePrincipal non riuscita",e);
  219.             }
  220.             esito.setErroreIntegrazione(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  221.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE));
  222.             esito.setClientIdentified(false);
  223.             esito.setEccezioneProcessamento(e);
  224.             return esito;
  225.         }
  226.         
  227.         if(idServizioApplicativo == null){
  228.             // L'identificazione in principal non e' obbligatoria
  229.             /**esito.setErroreIntegrazione(ErroriIntegrazione.ERRORE_402_AUTENTICAZIONE_FALLITA.getErrore402_AutenticazioneFallitaPrincipal(CostantiProtocollo.CREDENZIALI_FORNITE_NON_CORRETTE,principal));*/
  230.             esito.setClientIdentified(false);
  231.             return esito;
  232.         }
  233.         else {
  234.             if(OpenSPCoop2Properties.getInstance().isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari() && !idServizioApplicativo.getIdSoggettoProprietario().equals(soggettoFruitore)) {
  235.                 esito.setErroreIntegrazione(IntegrationFunctionError.AUTHENTICATION_INVALID_CREDENTIALS, 
  236.                         ErroriIntegrazione.ERRORE_402_AUTENTICAZIONE_FALLITA.
  237.                             getErrore402_AutenticazioneFallitaPrincipal("soggetto proprietario ("+idServizioApplicativo.getIdSoggettoProprietario()+") dell'applicativo identificato ("+idServizioApplicativo.getNome()+") differente dal soggetto proprietario della porta invocata ("+soggettoFruitore+")",principal));
  238.                 esito.setClientIdentified(false);
  239.                 return esito;
  240.             }
  241.             else { 
  242.                 esito.setClientIdentified(true);
  243.                 esito.setIdServizioApplicativo(idServizioApplicativo);
  244.             }
  245.         }
  246.         
  247.         return esito;
  248.         
  249.     }

  251.     @Override
  252.     public void cleanPostAuth(OpenSPCoop2Message message) throws AutenticazioneException {
  253.         AutenticazioneUtils.finalizeProcessPrincipal(message, this.tipoAutenticazionePrincipal, this.nome, this.cleanPrincipal);
  254.     }
  255. }
Created with JaCoCo 0.8.8.202204050719