AbstractAutorizzazioneXacmlPolicy.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.autorizzazione.pd;

  25. import java.util.List;

  27. import org.herasaf.xacml.core.context.impl.DecisionType;
  28. import org.herasaf.xacml.core.context.impl.ResultType;
  29. import org.openspcoop2.core.id.IDServizio;
  30. import org.openspcoop2.core.id.IDSoggetto;
  31. import org.openspcoop2.pdd.core.autorizzazione.AutorizzazioneException;
  32. import org.openspcoop2.pdd.core.autorizzazione.XACMLPolicyUtilities;
  33. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  34. import org.openspcoop2.protocol.sdk.constants.CodiceErroreIntegrazione;
  35. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  36. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  37. import org.openspcoop2.utils.SemaphoreLock;
  38. import org.openspcoop2.utils.xacml.MarshallUtilities;
  39. import org.openspcoop2.utils.xacml.ResultCombining;
  40. import org.openspcoop2.utils.xacml.ResultUtilities;
  41. import org.openspcoop2.utils.xacml.XacmlRequest;
  42. import org.slf4j.Logger;

  44. /**
  45.  * Classe che implementa una autorizzazione basata sui ruoli
  46.  *
  47.  * @author Andrea Poli (apoli@link.it)
  48.  * @author $Author$
  49.  * @version $Rev$, $Date$
  50.  */

  52. abstract class AbstractAutorizzazioneXacmlPolicy extends AbstractAutorizzazioneBase {


  55.     
  56.     private boolean checkRuoloRegistro;
  57.     private boolean checkRuoloEsterno;
  58.     private String nomeAutorizzazione;
  59.     private Logger log = null;
  60.     
  61.     protected AbstractAutorizzazioneXacmlPolicy(boolean checkRuoloRegistro, boolean checkRuoloEsterno, String nomeAutorizzazione){
  62.         this.checkRuoloRegistro = checkRuoloRegistro;
  63.         this.checkRuoloEsterno = checkRuoloEsterno;
  64.         this.nomeAutorizzazione = nomeAutorizzazione;
  65.         this.log = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  66.     }
  67.     
  68.     
  69.     private XacmlRequest xacmlRequest = null;
  70.     private String xacmlRequestAsString = null;
  71.     private String policyKey = null;
  72.     private org.openspcoop2.utils.Semaphore semaphore = new org.openspcoop2.utils.Semaphore("AbstractAutorizzazioneXacmlPolicyPD");
  73.     private XacmlRequest getXacmlRequest(DatiInvocazionePortaDelegata datiInvocazione, Logger log) throws AutorizzazioneException{
  74.         if(this.xacmlRequest==null){
  75.             initXacmlRequest(datiInvocazione, log);
  76.         }
  77.         return this.xacmlRequest;
  78.     }
  79.     private void initXacmlRequest(DatiInvocazionePortaDelegata datiInvocazione, Logger log) throws AutorizzazioneException{
  80.         SemaphoreLock lock = this.semaphore.acquireThrowRuntime("initXacmlRequest");
  81.         try {
  82.             if(this.xacmlRequest==null){
  83.                 this.policyKey = "http://govway.org/out/"+datiInvocazione.getIdPD().getNome();
  84.                 this.xacmlRequest = XACMLPolicyUtilities.newXacmlRequest(this.getProtocolFactory(), datiInvocazione, 
  85.                         this.checkRuoloRegistro, this.checkRuoloEsterno, this.policyKey);
  86.                 this.xacmlRequestAsString = new String(MarshallUtilities.marshallRequest(this.xacmlRequest));
  87.                 this.log.debug("XACML-Request (idPolicy:"+this.policyKey+"): "+this.xacmlRequestAsString);
  88.             }
  89.         }finally {
  90.             this.semaphore.release(lock, "initXacmlRequest");
  91.         }
  92.     }
  93.     
  94.     @Override
  95.     public String getSuffixKeyAuthorizationResultInCache(DatiInvocazionePortaDelegata datiInvocazione) {
  96.         try{
  97.             initDatiPolicy(datiInvocazione, false);
  98.         }catch(Exception e){
  99.             // Comunque l'errore verrà rilanciato anche durante l'utilizzo della classe vera e propria nel metodo 'process'
  100.             // quando viene effettuata la 'XACMLPolicyUtilities.loadPolicy'. 
  101.         }
  102.         return this.xacmlRequestAsString;
  103.     }

  105.     @Override
  106.     public boolean saveAuthorizationResultInCache() {
  107.         return true;
  108.     }
  109.     
  110.     private void initDatiPolicy(DatiInvocazionePortaDelegata datiInvocazione, boolean throwError) throws Exception {
  111.         if(this.xacmlRequestAsString==null){
  112.             try{
  113.                 this.getXacmlRequest(datiInvocazione, this.log);
  114.             }catch(Exception e){
  115.                 this.log.error("Autorizzazione "+this.nomeAutorizzazione+" non riuscita (create XACML-Request)",e);
  116.                 if(throwError) {
  117.                     throw e;
  118.                 }
  119.             }
  120.         }
  121.     }
  122.         
  123.     @Override
  124.     public EsitoAutorizzazionePortaDelegata process(DatiInvocazionePortaDelegata datiInvocazione) throws AutorizzazioneException{

  126.         EsitoAutorizzazionePortaDelegata esito = new EsitoAutorizzazionePortaDelegata();
  127.         
  128.         String servizioApplicativo = null;
  129.         if(datiInvocazione.getIdServizioApplicativo()!=null){
  130.             servizioApplicativo = datiInvocazione.getIdServizioApplicativo().getNome();
  131.         }

  133.         
  134.         // ****** Inizializzazione Policy Key (Serve per la chiave identificativa della policy e anche per la cache) ********
  135.         // Inizializzazione 'policyKey'
  136.         // Questo codice serve per creare la chiave della policy che poi viene utilizzata dal PdD
  137.         // Il codice viene anche usato nel metodo 'getSuffixKeyAuthorizationResultInCache', 
  138.         // e quindi in presenza di cache attiva, in questo metodo l'invocazione non effettua nessuna operazione.
  139.         // Se invece la cache non e' attiva, l'invocazione inizializza i dati della policy tra cui la 'policyKey'
  140.         try{
  141.             initDatiPolicy(datiInvocazione,true);
  142.         }catch(Exception e){
  143.             this.log.error("Autorizzazione "+this.nomeAutorizzazione+" ("+this.policyKey+") non riuscita (init XACML-Policy)",e);
  144.             esito.setErroreIntegrazione(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  145.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE));
  146.             esito.setAutorizzato(false);
  147.             esito.setEccezioneProcessamento(e);
  148.             return esito;
  149.         }
  150.         
  151.         
  152.         
  153.         
  154.         // ****** Raccolta Dati e Policy ********
  155.         
  156.         IDSoggetto fruitore = new IDSoggetto(datiInvocazione.getPd().getTipoSoggettoProprietario(), datiInvocazione.getPd().getNomeSoggettoProprietario());
  157.         IDServizio idServizio = datiInvocazione.getIdServizio();
  158.         
  159.         String xacmlPolicyPorta = null;
  160.         try{
  161.             if(datiInvocazione.getPd()!=null) {
  162.                 xacmlPolicyPorta = datiInvocazione.getPd().getXacmlPolicy();
  163.             }
  164.             XACMLPolicyUtilities.loadPolicy(xacmlPolicyPorta, idServizio, this.policyKey, true, fruitore, this.log);
  165.         }catch(Exception e){
  166.             this.log.error("Autorizzazione "+this.nomeAutorizzazione+" ("+this.policyKey+") non riuscita (load XACML-Policy)",e);
  167.             esito.setErroreIntegrazione(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  168.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE));
  169.             esito.setAutorizzato(false);
  170.             esito.setEccezioneProcessamento(e);
  171.             return esito;
  172.         }
  173.         
  174.         
  175.         
  176.         
  177.         // ****** Produzione XACMLRequest a partire dai dati ********
  178.         
  179.         XacmlRequest xacmlRequest = null;
  180.         try{
  181.             xacmlRequest = this.getXacmlRequest(datiInvocazione, this.log);
  182.         }catch(Exception e){
  183.             this.log.error("Autorizzazione "+this.nomeAutorizzazione+" ("+this.policyKey+") non riuscita (create XACML-Request)",e);
  184.             esito.setErroreIntegrazione(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  185.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE));
  186.             esito.setAutorizzato(false);
  187.             esito.setEccezioneProcessamento(e);
  188.             return esito;
  189.         }
  190.     
  191.         
  192.         
  193.         
  194.         // ****** Valutazione XACMLRequest con PdD ********
  195.         
  196.         List<ResultType> results = null;
  197.         try {           
  198.             results = ResultUtilities.evaluate(xacmlRequest, this.log, this.policyKey, XACMLPolicyUtilities.getPolicyDecisionPoint(this.log));
  199.         }catch(Exception e){
  200.             this.log.error("Autorizzazione "+this.nomeAutorizzazione+" ("+this.policyKey+") non riuscita (evaluate XACML-Request)",e);
  201.             esito.setErroreIntegrazione(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  202.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE));
  203.             esito.setAutorizzato(false);
  204.             esito.setEccezioneProcessamento(e);
  205.             return esito;
  206.         }
  207.         
  208.         DecisionType decision = ResultCombining.combineDenyOverrides(results);
  209.         if(DecisionType.PERMIT.equals(decision)) {
  210.             esito.setAutorizzato(true);
  211.             return esito;
  212.         } else {
  213.             try{
  214.                 String resultAsStringForLog = ResultUtilities.toRawString(results);
  215.                 this.log.error("Autorizzazione con XACMLPolicy fallita ("+this.policyKey+") ;\nrequest: "+this.xacmlRequestAsString+
  216.                         "\npolicy: "+xacmlPolicyPorta+
  217.                         "\nresults (size:"+results.size()+"): \n"+resultAsStringForLog);
  218.                 
  219.                 String resultAsString = ResultUtilities.toString(results, decision);
  220.                 esito.setAutorizzato(false);
  221.                 if(servizioApplicativo!=null){
  222.                     esito.setErroreIntegrazione(IntegrationFunctionError.AUTHORIZATION_POLICY_DENY, ErroriIntegrazione.ERRORE_404_AUTORIZZAZIONE_FALLITA_SA.
  223.                             getErrore404_AutorizzazioneFallitaServizioApplicativo(servizioApplicativo,resultAsString));
  224.                 }
  225.                 else{
  226.                     esito.setErroreIntegrazione(IntegrationFunctionError.AUTHORIZATION_POLICY_DENY, ErroriIntegrazione.ERRORE_404_AUTORIZZAZIONE_FALLITA_SA.
  227.                             getErrore404_AutorizzazioneFallitaServizioApplicativoAnonimo(resultAsString));
  228.                 }
  229.                 return esito;
  230.                 
  231.             }catch(Exception e){
  232.                 this.log.error("Autorizzazione "+this.nomeAutorizzazione+" ("+this.policyKey+") fallita (read XACML-Results)",e);
  233.                 esito.setErroreIntegrazione(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  234.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE));
  235.                 esito.setAutorizzato(false);
  236.                 esito.setEccezioneProcessamento(e);
  237.                 return esito;
  238.             }
  239.         }
  240.         
  241.     }

  243.    
  244. }
Created with JaCoCo 0.8.8.202204050719