Helper.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.core.config.rs.server.api.impl;

  22. import java.lang.reflect.InvocationTargetException;
  23. import java.lang.reflect.Method;
  24. import java.util.AbstractMap.SimpleEntry;
  25. import java.util.ArrayList;
  26. import java.util.HashMap;
  27. import java.util.List;
  28. import java.util.Map;
  29. import java.util.stream.Collectors;
  30. import java.util.stream.Stream;

  32. import org.apache.commons.beanutils.BeanUtils;
  33. import org.apache.commons.lang.StringUtils;
  34. import org.openspcoop2.core.commons.Filtri;
  35. import org.openspcoop2.core.config.constants.CredenzialeTipo;
  36. import org.openspcoop2.core.config.rs.server.config.ServerProperties;
  37. import org.openspcoop2.core.config.rs.server.model.AuthenticationApiKey;
  38. import org.openspcoop2.core.config.rs.server.model.AuthenticationHttpBasic;
  39. import org.openspcoop2.core.config.rs.server.model.AuthenticationHttps;
  40. import org.openspcoop2.core.config.rs.server.model.AuthenticationHttpsBaseCertificato;
  41. import org.openspcoop2.core.config.rs.server.model.AuthenticationHttpsCertificato;
  42. import org.openspcoop2.core.config.rs.server.model.AuthenticationHttpsConfigurazioneManuale;
  43. import org.openspcoop2.core.config.rs.server.model.AuthenticationPrincipal;
  44. import org.openspcoop2.core.config.rs.server.model.AuthenticationToken;
  45. import org.openspcoop2.core.config.rs.server.model.AuthenticationTokenBase;
  46. import org.openspcoop2.core.config.rs.server.model.ModalitaAccessoEnum;
  47. import org.openspcoop2.core.config.rs.server.model.OneOfBaseCredenzialiCredenziali;
  48. import org.openspcoop2.core.config.rs.server.model.TipoAutenticazioneHttps;
  49. import org.openspcoop2.core.config.rs.server.model.TipoKeystore;
  50. import org.openspcoop2.core.id.IDSoggetto;
  51. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  52. import org.openspcoop2.core.registry.CredenzialiSoggetto;
  53. import org.openspcoop2.core.registry.beans.AccordoServizioParteComuneSintetico;
  54. import org.openspcoop2.core.registry.constants.StatoFunzionalita;
  55. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  56. import org.openspcoop2.protocol.manifest.constants.ServiceBinding;
  57. import org.openspcoop2.utils.Utilities;
  58. import org.openspcoop2.utils.UtilsException;
  59. import org.openspcoop2.utils.certificate.ArchiveLoader;
  60. import org.openspcoop2.utils.certificate.ArchiveType;
  61. import org.openspcoop2.utils.certificate.CertificateInfo;
  62. import org.openspcoop2.utils.mime.MimeTypes;
  63. import org.openspcoop2.utils.service.beans.Lista;
  64. import org.openspcoop2.utils.service.beans.ProfiloEnum;
  65. import org.openspcoop2.utils.service.context.IContext;
  66. import org.openspcoop2.utils.service.fault.jaxrs.FaultCode;
  67. import org.openspcoop2.utils.transport.http.HttpConstants;
  68. import org.openspcoop2.web.ctrlstat.core.ConsoleSearch;
  69. import org.openspcoop2.web.ctrlstat.servlet.ConsoleHelper;
  70. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneCore;
  71. import org.openspcoop2.web.ctrlstat.servlet.connettori.ConnettoriCostanti;
  72. import org.openspcoop2.web.lib.mvc.BinaryParameter;
  73. import org.openspcoop2.web.lib.mvc.Costanti;
  74. import org.openspcoop2.web.lib.mvc.ServletUtils;

  76. /**
  77.  * Helper
  78.  * 
  79.  * @author $Author$
  80.  * @version $Rev$, $Date$
  81.  * 
  82.  */
  83. public class Helper extends org.openspcoop2.utils.service.beans.utils.BaseHelper {
  84.     
  85.     
  86.     
  87.     public static <T extends Lista> T returnOrNotFound(T ret ) throws UtilsException {
  88.         boolean throwIfEmpty = ServerProperties.getInstance().isFindall404();
  89.         
  90.         if ( (ret == null || ret.getTotal() <= 0 ) && throwIfEmpty ) 
  91.             throw FaultCode.NOT_FOUND.toException("Nessun elemento corrisponde ai criteri di ricerca");
  92.         
  93.         return ret;
  94.     }
  95.     
  96.     /**
  97.      * Converte un enum in un altro enum supposto che i valori di enumerazione siano identici.
  98.      * Questo si presta bene a conversioni del tipo HttpMethodEnum -> HttpMethod. In questo caso, pur avendo
  99.      * il primo enum un valore in più - QUALSIASI-, esso viene tradotto a null così come richiesto dalla console.
  100.      *  
  101.      * Potrei utilizzare un terzo parametro per sollevare un eccezione in caso di mancata conversione
  102.      */
  103.     public static final <E1 extends Enum<E1>,E2 extends Enum<E2>> E2 apiEnumToGovway(E1 aenum, Class<E2> toClass  ) {
  104.         
  105.         try {
  106.             return Enum.valueOf(toClass, aenum.name());
  107.         } catch(Exception e) {
  108.             return null;
  109.         }
  110.     //   BeanUtils.setProperty(ret, "tipo", Enum.valueOf( (Class<Enum>)enumClass, "BASIC"));
  111.     //   return Enum.valueOf( (Class<Enum>)toClass, "BASIC")
  112.     }

  114.     public static final Map<CredenzialeTipo,ModalitaAccessoEnum> modalitaAccessoFromCredenzialeTipo = new HashMap<>();
  115.     static {
  116.         modalitaAccessoFromCredenzialeTipo.put(CredenzialeTipo.BASIC, ModalitaAccessoEnum.HTTP_BASIC);
  117.         modalitaAccessoFromCredenzialeTipo.put(CredenzialeTipo.PRINCIPAL, ModalitaAccessoEnum.PRINCIPAL);
  118.         modalitaAccessoFromCredenzialeTipo.put(CredenzialeTipo.SSL, ModalitaAccessoEnum.HTTPS);
  119.         modalitaAccessoFromCredenzialeTipo.put(CredenzialeTipo.APIKEY, ModalitaAccessoEnum.API_KEY);
  120.         modalitaAccessoFromCredenzialeTipo.put(CredenzialeTipo.TOKEN, ModalitaAccessoEnum.TOKEN);
  121.     }
  122.     
  123.     public static final Map<ModalitaAccessoEnum,CredenzialeTipo> credenzialeTipoFromModalitaAccesso = new HashMap<ModalitaAccessoEnum,CredenzialeTipo>();
  124.     static {
  125.         modalitaAccessoFromCredenzialeTipo.forEach( (cred,mod) -> credenzialeTipoFromModalitaAccesso.put(mod, cred));
  126.     }

  128.     
  129.     public static final Map<ModalitaAccessoEnum,String> tipoAuthFromModalitaAccesso = new HashMap<ModalitaAccessoEnum,String>();
  130.     static {
  131.         tipoAuthFromModalitaAccesso.put(ModalitaAccessoEnum.HTTPS, ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL);
  132.         tipoAuthFromModalitaAccesso.put(ModalitaAccessoEnum.HTTP_BASIC, ConnettoriCostanti.AUTENTICAZIONE_TIPO_BASIC);
  133.         tipoAuthFromModalitaAccesso.put(ModalitaAccessoEnum.PRINCIPAL, ConnettoriCostanti.AUTENTICAZIONE_TIPO_PRINCIPAL);
  134.         tipoAuthFromModalitaAccesso.put(ModalitaAccessoEnum.API_KEY, ConnettoriCostanti.AUTENTICAZIONE_TIPO_APIKEY);
  135.         tipoAuthFromModalitaAccesso.put(ModalitaAccessoEnum.TOKEN, ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN);
  136.         tipoAuthFromModalitaAccesso.put(null, ConnettoriCostanti.AUTENTICAZIONE_TIPO_NESSUNA);
  137.     }

  139.     public static final Map<String,String> tipoAuthSAFromModalita = Stream.of(
  140.             new SimpleEntry<>("http-basic", ConnettoriCostanti.AUTENTICAZIONE_TIPO_BASIC),
  141.             new SimpleEntry<>("https", ConnettoriCostanti.AUTENTICAZIONE_TIPO_SSL),
  142.             new SimpleEntry<>("principal",ConnettoriCostanti.AUTENTICAZIONE_TIPO_PRINCIPAL),
  143.             new SimpleEntry<>("api-key",ConnettoriCostanti.AUTENTICAZIONE_TIPO_APIKEY),
  144.             new SimpleEntry<>("token",ConnettoriCostanti.AUTENTICAZIONE_TIPO_TOKEN),
  145.             new SimpleEntry<>("custom", ConnettoriCostanti.AUTENTICAZIONE_TIPO_NESSUNA)
  146.         ).collect(Collectors.toMap(SimpleEntry::getKey, SimpleEntry::getValue));


  149.     public static ProfiloEnum getProfiloDefault() throws UtilsException {
  150.         ServerProperties serverProperties = ServerProperties.getInstance();
  151.         
  152.         return profiloFromTipoProtocollo.get(serverProperties.getProtocolloDefault());
  153.     }


  156.     public static String getProtocolloOrDefault(ProfiloEnum profilo) throws UtilsException {
  157.         ServerProperties serverProperties = ServerProperties.getInstance();
  158.         String tipo_protocollo = null;
  159.         
  160.         String modalita = profilo!=null ? profilo.toString() : null;
  161.         if (modalita == null || modalita.length() == 0) {
  162.             tipo_protocollo = serverProperties.getProtocolloDefault();
  163.         }
  164.         
  165.         else {
  166.             tipo_protocollo = tipoProtocolloFromProfilo.get(profilo);
  167.         }
  168.         
  169.         if (tipo_protocollo == null) {
  170.             StringBuilder sb = new StringBuilder("Impossible recuperare il profilo di interoperabilità dalla modalità: ");
  171.             sb.append(modalita);
  172.             throw FaultCode.RICHIESTA_NON_VALIDA.toException(sb.toString());
  173.         }
  174.         
  175.         return tipo_protocollo;
  176.     }


  179.     public static final String getSoggettoOrDefault(String soggetto, ProfiloEnum profilo) throws UtilsException {
  180.         
  181.         if (soggetto == null || soggetto.length() == 0) {
  182.             ServerProperties serverProperties = ServerProperties.getInstance();
  183.             soggetto = serverProperties.getSoggettoDefault(profilo!=null ? profilo.toString() : null);
  184.         }
  185.         
  186.         return soggetto;
  187.     }
  188.     
  189.     public static void overrideAuthParams(HttpRequestWrapper wrap, ConsoleHelper consoleHelper, OneOfBaseCredenzialiCredenziali credenziali, 
  190.             ApiKeyInfo apiKeyInfo, boolean updateKey) {
  191.         
  192.         ModalitaAccessoEnum modalitaAccesso = credenziali.getModalitaAccesso();
  193.         if(modalitaAccesso == null) {
  194.             throw FaultCode.RICHIESTA_NON_VALIDA.toException("Modalità di accesso delle credenziali non indicata");
  195.         }
  196.         
  197.         switch(modalitaAccesso) {
  198.         case HTTP_BASIC: {
  199.             
  200.             if(! (credenziali instanceof AuthenticationHttpBasic)) {
  201.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Credenziali '"+credenziali.getClass().getName()+"' non compatibili con la modalità '+"+modalitaAccesso.toString()+"+'");
  202.             }
  203.             
  204.             AuthenticationHttpBasic c = (AuthenticationHttpBasic) credenziali;
  205.             wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_USERNAME, c.getUsername());
  206.             wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PASSWORD, c.getPassword());
  207.             if(c.getPassword()!=null && StringUtils.isNotEmpty(c.getPassword())) {
  208.                 wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CHANGE_PASSWORD, 
  209.                         Costanti.CHECK_BOX_CONFIG_ENABLE);
  210.             }
  211.             
  212.             break;
  213.         }
  214.         case API_KEY: {
  215.             
  216.             if(! (credenziali instanceof AuthenticationApiKey)) {
  217.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Credenziali '"+credenziali.getClass().getName()+"' non compatibili con la modalità '+"+modalitaAccesso.toString()+"+'");
  218.             }
  219.             
  220.             AuthenticationApiKey c = (AuthenticationApiKey) credenziali;
  221.             boolean appId = isAppId(c.isAppId());
  222.             wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_MULTIPLE_API_KEYS, appId ? Costanti.CHECK_BOX_CONFIG_ENABLE : Costanti.CHECK_BOX_CONFIG_DISABLE);
  223.             wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_APP_ID, apiKeyInfo.getAppId());
  224.             wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_API_KEY, apiKeyInfo.getApiKey());
  225.             wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PASSWORD, apiKeyInfo.getPassword());
  226.             if(updateKey) {
  227.                 wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CHANGE_PASSWORD, 
  228.                         Costanti.CHECK_BOX_CONFIG_ENABLE);
  229.             }
  230.             
  231.             break;
  232.         }
  233.         case HTTPS: {
  234.             
  235.             if(! (credenziali instanceof AuthenticationHttps)) {
  236.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Credenziali '"+credenziali.getClass().getName()+"' non compatibili con la modalità '+"+modalitaAccesso.toString()+"+'");
  237.             }
  238.                         
  239.             AuthenticationHttps c = (AuthenticationHttps) credenziali;
  240.             wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_WIZARD_STEP,
  241.                     ConnettoriCostanti.VALUE_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_NO_WIZARD);
  242.             
  243.             switch (c.getCertificato().getTipo()) {
  244.             case CERTIFICATO:
  245.                 
  246.                 if(c.getCertificato() instanceof AuthenticationHttpsCertificato) {
  247.                 
  248.                     wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL,
  249.                             ConnettoriCostanti.VALUE_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_UPLOAD_CERTIFICATO);
  250.                     AuthenticationHttpsCertificato certificate = (AuthenticationHttpsCertificato) c.getCertificato();
  251.                     consoleHelper.registerBinaryParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_FILE_CERTIFICATO, certificate.getArchivio());
  252.                     wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_TIPO_ARCHIVIO, certificate.getTipoCertificato().toString());
  253.                     wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_ALIAS_CERTIFICATO, certificate.getAlias());
  254.                     wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_FILE_CERTIFICATO_PASSWORD, certificate.getPassword());
  255.                     
  256.                     wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_VERIFICA_TUTTI_CAMPI, 
  257.                             certificate.isStrictVerification()? Costanti.CHECK_BOX_ENABLED : Costanti.CHECK_BOX_CONFIG_DISABLE);
  258.                     
  259.                 }
  260.                 else {
  261.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Certificato fornito '"+c.getCertificato().getClass().getName()+"' non compatibile con il tipo '"+c.getCertificato().getTipo()+"' ");
  262.                 }
  263.                 
  264.                 break;
  265.             case CONFIGURAZIONE_MANUALE:
  266.                 
  267.                 if(c.getCertificato() instanceof AuthenticationHttpsConfigurazioneManuale) {
  268.                     
  269.                     wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL,
  270.                             ConnettoriCostanti.VALUE_PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CONFIGURAZIONE_SSL_CONFIGURAZIONE_MANUALE);
  271.                     AuthenticationHttpsConfigurazioneManuale creManuale = (AuthenticationHttpsConfigurazioneManuale) c.getCertificato();
  272.                     wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_SUBJECT, creManuale.getSubject());
  273.                     wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_ISSUER, creManuale.getIssuer());
  274.                     
  275.                 }
  276.                 else {
  277.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Certificato fornito '"+c.getCertificato().getClass().getName()+"' non compatibile con il tipo '"+c.getCertificato().getTipo()+"' ");
  278.                 }
  279.                 
  280.                 break;
  281.             }
  282.             
  283.             // Token per Modi insieme al certificato
  284.             if(c.getToken()!=null) {
  285.                 wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_TOKEN_CLIENT_ID, c.getToken().getIdentificativo());
  286.                 wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_TOKEN_POLICY,c.getToken().getTokenPolicy());
  287.             }
  288.             
  289.             break;
  290.         }
  291.         case PRINCIPAL: {
  292.             
  293.             if(! (credenziali instanceof AuthenticationPrincipal)) {
  294.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Credenziali '"+credenziali.getClass().getName()+"' non compatibili con la modalità '+"+modalitaAccesso.toString()+"+'");
  295.             }
  296.             
  297.             AuthenticationPrincipal c = (AuthenticationPrincipal) credenziali;
  298.             wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_PRINCIPAL, c.getUserid());
  299.             break;
  300.         }
  301.         case TOKEN: {
  302.             
  303.             if(! (credenziali instanceof AuthenticationToken)) {
  304.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Credenziali '"+credenziali.getClass().getName()+"' non compatibili con la modalità '+"+modalitaAccesso.toString()+"+'");
  305.             }
  306.             
  307.             AuthenticationToken c = (AuthenticationToken) credenziali;
  308.             wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_TOKEN_CLIENT_ID, c.getIdentificativo());
  309.             wrap.overrideParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_TOKEN_POLICY,c.getTokenPolicy());
  310.             break;
  311.         }
  312.         }
  313.     }
  314.     
  315.     
  316.     /**
  317.      * Swagger passa le credenziali come una linkedHashMap.
  318.      * Dobbiamo trasformarla nei relativi oggetti di autenticazione.
  319.      * 
  320.      * @param applicativo
  321.      * @return
  322.      * @throws Exception
  323.      */
  324.     public static OneOfBaseCredenzialiCredenziali translateCredenziali(OneOfBaseCredenzialiCredenziali creds, boolean create) {
  325.         
  326.         if(creds==null || creds.getModalitaAccesso()==null) {
  327.             return null;
  328.         }
  329.         
  330.         OneOfBaseCredenzialiCredenziali ret = null;
  331.         ModalitaAccessoEnum tipoAuth = creds.getModalitaAccesso();
  332.     
  333.         switch (tipoAuth) {
  334.         case HTTP_BASIC: {
  335.             ret = (AuthenticationHttpBasic) creds;
  336.             if(create) {
  337.                 AuthenticationHttpBasic basic = (AuthenticationHttpBasic) ret;
  338.                 if(basic.getPassword()==null || StringUtils.isEmpty(basic.getPassword())) {
  339.                     throw FaultCode.RICHIESTA_NON_VALIDA.toException("Nell'operazione richiesta è obbligatorio indicare la password per il tipo di autenticazione '"+tipoAuth+"'");
  340.                 }
  341.             }
  342.             break;
  343.         }
  344.         case HTTPS: {
  345.             ret = (AuthenticationHttps) creds;
  346.             break;
  347.         }
  348.         case PRINCIPAL: {
  349.             ret = (AuthenticationPrincipal) creds;
  350.             break;
  351.         }
  352.         case API_KEY: {
  353.             ret = (AuthenticationApiKey) creds;
  354.             break;
  355.         }
  356.         case TOKEN: {
  357.             ret = (AuthenticationToken) creds;
  358.             break;
  359.         }
  360.         default:
  361.             ret = null;
  362.             break;
  363.             
  364.         }
  365.         return ret;
  366.     }
  367.     
  368.     /**
  369.      * Trasforma un oggetto di tipo credenziali parte API (è assunto ben formato) nei numerosi oggetti Credenziale* generati
  370.      * automaticamente all'interno del progetto e identici.
  371.      * 
  372.      * @param creds
  373.      * @param tipoAuth
  374.      * @param credClass La classe verso cui tradurre
  375.      * @param enumClass La modalità di accesso, ovvero il campo "tipo" della classe verso cui tradurre.
  376.      * @throws UtilsException 
  377.      */
  378.     
  379.     // TODO: Manage exceptions.
  380.     @SuppressWarnings({ "unchecked", "rawtypes" })
  381.     public static <T,E> List<T> apiCredenzialiToGovwayCred(Object creds, ModalitaAccessoEnum tipoAuth, Class<T> credClass, Class<E> enumClass, ApiKeyInfo keyInfo)
  382.             throws IllegalAccessException, InvocationTargetException, InstantiationException, UtilsException {
  383.         
  384.         if (!enumClass.isEnum())
  385.             throw new IllegalArgumentException("Il parametro enumClass deve essere un'enumerazione");
  386.         
  387.         List<T> lstRet = new ArrayList<T>();
  388.         
  389.         T ret = Utilities.newInstance(credClass);
  390.         
  391.         switch (tipoAuth) {
  392.         case HTTP_BASIC: {
  393.             
  394.             if(! (creds instanceof AuthenticationHttpBasic)) {
  395.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Credenziali '"+creds.getClass().getName()+"' non compatibili con la modalità '+"+tipoAuth.toString()+"+'");
  396.             }
  397.             
  398.             AuthenticationHttpBasic auth = (AuthenticationHttpBasic) creds;
  399.             BeanUtils.setProperty(ret, "tipo", Enum.valueOf( (Class<Enum>)enumClass, "BASIC"));
  400.             BeanUtils.setProperty(ret, "user", auth.getUsername());
  401.             BeanUtils.setProperty(ret, "password", auth.getPassword());
  402.             lstRet.add(ret);
  403.             break;
  404.         }
  405.         case HTTPS: {
  406.             
  407.             if(! (creds instanceof AuthenticationHttps)) {
  408.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Credenziali '"+creds.getClass().getName()+"' non compatibili con la modalità '+"+tipoAuth.toString()+"+'");
  409.             }
  410.             
  411.             AuthenticationHttps auth = (AuthenticationHttps) creds;
  412.             BeanUtils.setProperty(ret, "tipo", Enum.valueOf( (Class<Enum>)enumClass, "SSL"));
  413.             switch (auth.getCertificato().getTipo()) {
  414.             case CERTIFICATO:
  415.                 AuthenticationHttpsCertificato cre = (AuthenticationHttpsCertificato) auth.getCertificato();
  416.                 ArchiveType type = ArchiveType.CER;
  417.                 String alias = cre.getAlias();
  418.                 String password = cre.getPassword();
  419.                 if(cre.getTipoCertificato()!=null) {
  420.                     type = ArchiveType.valueOf(cre.getTipoCertificato().toString());
  421.                 }
  422.                 CertificateInfo cInfo = ArchiveLoader.load(type, cre.getArchivio(), alias, password).getCertificate();
  423.                 BeanUtils.setProperty(ret, "certificate", cre.getArchivio());
  424.                 BeanUtils.setProperty(ret, "certificateStrictVerification", cre.isStrictVerification());
  425.                 BeanUtils.setProperty(ret, "cnSubject", cInfo.getSubject().getCN());
  426.                 BeanUtils.setProperty(ret, "cnIssuer", cInfo.getIssuer().getCN());  
  427.                 lstRet.add(ret);
  428.                 
  429.                 // lettura altri certificati
  430.                 List<AuthenticationHttpsBaseCertificato> certificati = auth.getCertificati();
  431.                 if(certificati!= null && certificati.size() > 0) {
  432.                     for (AuthenticationHttpsBaseCertificato secondaryCre : certificati) {
  433.                         T cert = Utilities.newInstance(credClass);
  434.                         BeanUtils.setProperty(cert, "tipo", Enum.valueOf( (Class<Enum>)enumClass, "SSL"));
  435.                         
  436.                         ArchiveType secondaryType = ArchiveType.CER;
  437.                         String secondaryAlias = secondaryCre.getAlias();
  438.                         String secondaryPassword = secondaryCre.getPassword();
  439.                         if(secondaryCre.getTipoCertificato()!=null) {
  440.                             secondaryType = ArchiveType.valueOf(secondaryCre.getTipoCertificato().toString());
  441.                         }
  442.                         CertificateInfo secondaryCInfo = ArchiveLoader.load(secondaryType, secondaryCre.getArchivio(), secondaryAlias, secondaryPassword).getCertificate();
  443.                         BeanUtils.setProperty(cert, "certificate", secondaryCre.getArchivio());
  444.                         BeanUtils.setProperty(cert, "certificateStrictVerification", secondaryCre.isStrictVerification());
  445.                         BeanUtils.setProperty(cert, "cnSubject", secondaryCInfo.getSubject().getCN());
  446.                         BeanUtils.setProperty(cert, "cnIssuer", secondaryCInfo.getIssuer().getCN());    
  447.                         
  448.                         lstRet.add(cert);
  449.                     }
  450.                 }
  451.                 
  452.                 break;
  453.             case CONFIGURAZIONE_MANUALE:
  454.                 AuthenticationHttpsConfigurazioneManuale creManuale = (AuthenticationHttpsConfigurazioneManuale) auth.getCertificato();
  455.                 BeanUtils.setProperty(ret, "subject", creManuale.getSubject());
  456.                 BeanUtils.setProperty(ret, "issuer", creManuale.getIssuer());
  457.                 lstRet.add(ret);
  458.                 break;
  459.             }
  460.             
  461.             // Token per Modi insieme al certificato
  462.             if(auth.getToken()!=null) {
  463.                 BeanUtils.setProperty(ret, "user", auth.getToken().getIdentificativo());
  464.                 BeanUtils.setProperty(ret, "tokenPolicy", auth.getToken().getTokenPolicy());
  465.             }
  466.             
  467.             break;
  468.         }
  469.         case PRINCIPAL: {
  470.             
  471.             if(! (creds instanceof AuthenticationPrincipal)) {
  472.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Credenziali '"+creds.getClass().getName()+"' non compatibili con la modalità '+"+tipoAuth.toString()+"+'");
  473.             }
  474.             
  475.             AuthenticationPrincipal auth = (AuthenticationPrincipal) creds;
  476.             BeanUtils.setProperty(ret, "tipo", Enum.valueOf( (Class<Enum>)enumClass, "PRINCIPAL"));
  477.             BeanUtils.setProperty(ret, "user", auth.getUserid());
  478.             lstRet.add(ret);
  479.             break;
  480.         }
  481.         case API_KEY: {
  482.             
  483.             if(! (creds instanceof AuthenticationApiKey)) {
  484.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Credenziali '"+creds.getClass().getName()+"' non compatibili con la modalità '+"+tipoAuth.toString()+"+'");
  485.             }
  486.             if(keyInfo==null) {
  487.                 throw new UtilsException("KeyInfo unavailable");
  488.             }
  489.             
  490.             AuthenticationApiKey auth = (AuthenticationApiKey) creds;
  491.             BeanUtils.setProperty(ret, "tipo", Enum.valueOf( (Class<Enum>)enumClass, "APIKEY"));
  492.             BeanUtils.setProperty(ret, "user", keyInfo.getAppId());
  493.             BeanUtils.setProperty(ret, "password", keyInfo.getPassword());
  494.             boolean appId = isAppId(auth.isAppId());
  495.             BeanUtils.setProperty(ret, "appId", appId);
  496.             BeanUtils.setProperty(ret, "certificateStrictVerification", keyInfo.isCifrata());
  497.             lstRet.add(ret);
  498.             break;
  499.         }
  500.         
  501.         case TOKEN: {
  502.             
  503.             if(! (creds instanceof AuthenticationToken)) {
  504.                 throw FaultCode.RICHIESTA_NON_VALIDA.toException("Credenziali '"+creds.getClass().getName()+"' non compatibili con la modalità '+"+tipoAuth.toString()+"+'");
  505.             }
  506.         
  507.             AuthenticationToken auth = (AuthenticationToken) creds;
  508.             BeanUtils.setProperty(ret, "tipo", Enum.valueOf( (Class<Enum>)enumClass, "TOKEN"));
  509.             BeanUtils.setProperty(ret, "user", auth.getIdentificativo());
  510.             BeanUtils.setProperty(ret, "tokenPolicy", auth.getTokenPolicy());
  511.             lstRet.add(ret);
  512.             break;
  513.         }
  514.         
  515.         default:
  516.             BeanUtils.setProperty(ret, "tipo", null);
  517.             lstRet.add(ret);
  518.             break;
  519.         }
  520.         
  521.         return lstRet;
  522.     }

  524.     
  525.     public static final <T,E> OneOfBaseCredenzialiCredenziali govwayCredenzialiToApi(List<?> govwayCredsList, Class<T> credClass, Class<E> enumClass) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
  526.         
  527.         if (!enumClass.isEnum())
  528.             throw new IllegalArgumentException("Il parametro enumClass deve essere un'enumerazione");
  529.         
  530.         OneOfBaseCredenzialiCredenziali ret = null;     
  531.         
  532.         // Questo è il caso di autenticazione di tipo NESSUNO.
  533.         if (govwayCredsList == null)
  534.             return ret;
  535.         
  536.         Object govwayCreds = govwayCredsList.get(0); // riportato dal metodo chiamante
  537.         
  538.         String tipo = BeanUtils.getProperty(govwayCreds, "tipo");
  539.         
  540.         if ("basic".equals(tipo)) {
  541.             AuthenticationHttpBasic auth = new AuthenticationHttpBasic();
  542.             auth.setUsername(BeanUtils.getProperty(govwayCreds, "user"));
  543.             
  544.             Method mCertificateStrictVerification = credClass.getMethod("isCertificateStrictVerification");
  545.             boolean cifrata = (Boolean) mCertificateStrictVerification.invoke(govwayCreds);
  546.             if(!cifrata) {
  547.                 auth.setPassword(BeanUtils.getProperty(govwayCreds, "password"));
  548.             }
  549.             auth.setModalitaAccesso(ModalitaAccessoEnum.HTTP_BASIC);
  550.             ret = auth;
  551.         }
  552.         else if ("ssl".equals(tipo)) {
  553.             AuthenticationHttps auth = new AuthenticationHttps();
  554.             Method mCertificate = credClass.getMethod("getCertificate");
  555.             Object oCertificate = mCertificate.invoke(govwayCreds);
  556.             if(oCertificate==null) {
  557.                 AuthenticationHttpsConfigurazioneManuale manuale = new AuthenticationHttpsConfigurazioneManuale();
  558.                 manuale.setTipo(TipoAutenticazioneHttps.CONFIGURAZIONE_MANUALE);
  559.                 manuale.setSubject(BeanUtils.getProperty(govwayCreds, "subject"));  
  560.                 manuale.setIssuer(BeanUtils.getProperty(govwayCreds, "issuer"));    
  561.                 auth.setCertificato(manuale);
  562.             }
  563.             else {
  564.                 AuthenticationHttpsCertificato certificato = new AuthenticationHttpsCertificato();
  565.                 certificato.setTipo(TipoAutenticazioneHttps.CERTIFICATO);
  566.                 certificato.setTipoCertificato(TipoKeystore.CER);
  567.                 certificato.setArchivio((byte[])oCertificate);
  568.                 Method mCertificateStrictVerification = credClass.getMethod("isCertificateStrictVerification");
  569.                 certificato.setStrictVerification((Boolean) mCertificateStrictVerification.invoke(govwayCreds));
  570.                 auth.setCertificato(certificato);
  571.             }
  572.             auth.setModalitaAccesso(ModalitaAccessoEnum.HTTPS);
  573.             
  574.             if(govwayCredsList.size() > 1) { // riporto i certificati aggiuntivi
  575.                 List<AuthenticationHttpsBaseCertificato> certificati = new ArrayList<AuthenticationHttpsBaseCertificato>();
  576.                 for (int i = 1; i < govwayCredsList.size(); i++) {
  577.                     Object govwayCredsCertificato = govwayCredsList.get(i);
  578.                     AuthenticationHttpsBaseCertificato certificato = new AuthenticationHttpsBaseCertificato();
  579.                     certificato.setTipoCertificato(TipoKeystore.CER);
  580.                     Object oCertificateCertificato = mCertificate.invoke(govwayCredsCertificato);
  581.                     certificato.setArchivio((byte[])oCertificateCertificato);
  582.                     Method mCertificateStrictVerification = credClass.getMethod("isCertificateStrictVerification");
  583.                     certificato.setStrictVerification((Boolean) mCertificateStrictVerification.invoke(govwayCredsCertificato));
  584.                     
  585.                     certificati.add(certificato );
  586.                 }
  587.                 auth.setCertificati(certificati );
  588.             }   
  589.             
  590.             // Token per Modi insieme al certificato
  591.             String credenzialiSoggettoClassName = CredenzialiSoggetto.class.getName()+"";
  592.             if(!credenzialiSoggettoClassName.equals(credClass.getName())) {
  593.                 String identificativo = BeanUtils.getProperty(govwayCreds, "user");
  594.                 String tokenPolicy = BeanUtils.getProperty(govwayCreds, "tokenPolicy");
  595.                 if(tokenPolicy!=null && identificativo!=null) {
  596.                     AuthenticationTokenBase modiToken = new AuthenticationTokenBase();
  597.                     modiToken.setIdentificativo(identificativo);
  598.                     modiToken.setTokenPolicy(tokenPolicy);
  599.                     auth.setToken(modiToken);
  600.                 }
  601.             }
  602.         
  603.             ret = auth;
  604.         }
  605.         else if ("principal".equals(tipo)) {
  606.             AuthenticationPrincipal auth = new AuthenticationPrincipal();
  607.             auth.setUserid(BeanUtils.getProperty(govwayCreds, "user"));
  608.             auth.setModalitaAccesso(ModalitaAccessoEnum.PRINCIPAL);
  609.             ret = auth;
  610.         }
  611.         else if ("apikey".equals(tipo)) {
  612.             AuthenticationApiKey auth = new AuthenticationApiKey();
  613.             Method mAppId = credClass.getMethod("isAppId");
  614.             boolean appId = (Boolean) mAppId.invoke(govwayCreds);
  615.             auth.setAppId(appId);
  616.             auth.setModalitaAccesso(ModalitaAccessoEnum.API_KEY);
  617.             ret = auth;
  618.         }
  619.         else if ("token".equals(tipo)) {
  620.             AuthenticationToken auth = new AuthenticationToken();
  621.             auth.setIdentificativo(BeanUtils.getProperty(govwayCreds, "user"));
  622.             auth.setTokenPolicy(BeanUtils.getProperty(govwayCreds, "tokenPolicy"));
  623.             auth.setModalitaAccesso(ModalitaAccessoEnum.TOKEN);
  624.             ret = auth;
  625.         }
  626.         
  627.         return ret;
  628.     }
  629.     
  630.     
  631.     public static final ModalitaAccessoEnum credenzialiToModalita(Object obj) {
  632.         if (obj == null) return null;
  633.         
  634.         if (obj instanceof AuthenticationHttpBasic)
  635.             return ModalitaAccessoEnum.HTTP_BASIC;
  636.         
  637.         if (obj instanceof AuthenticationHttps)
  638.             return ModalitaAccessoEnum.HTTPS;
  639.         
  640.         if (obj instanceof AuthenticationPrincipal)
  641.             return ModalitaAccessoEnum.PRINCIPAL;
  642.         else
  643.             throw new IllegalArgumentException("credenzialiToModalita(): Tipo argomento sconosciuto");
  644.     }
  645.     
  646.     


  649.     public static final ConsoleSearch setupRicercaPaginata(String q, Integer limit, Integer offset, int idLista) {
  650.         ConsoleSearch ricerca = new ConsoleSearch();
  651.         
  652.         if (limit != null && limit != 0)
  653.             ricerca.setPageSize(idLista, limit);
  654.         if (offset != null)
  655.             ricerca.setIndexIniziale(idLista, offset);
  656.         if (q == null) q = "";
  657.         
  658.         q = q.trim();
  659.         if (q.equals("")) {
  660.             ricerca.setSearchString(idLista, org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED);
  661.         } else {
  662.             ricerca.setSearchString(idLista, q);
  663.         }
  664.         return ricerca;
  665.     }
  666.     
  667.     public static final ConsoleSearch setupRicercaPaginata(String q, Integer limit, Integer offset, int idLista, IDSoggetto idSoggetto, String tipo_protocollo) {
  668.         ConsoleSearch ricerca = setupRicercaPaginata( q, limit, offset, idLista );
  669.         
  670.         ricerca.addFilter(idLista, Filtri.FILTRO_SOGGETTO, idSoggetto.toString());
  671.         ricerca.addFilter(idLista, Filtri.FILTRO_PROTOCOLLO, tipo_protocollo );
  672.         return ricerca;
  673.     }
  674.     
  675.     
  676.     public static final boolean statoFunzionalitaToBool(StatoFunzionalita sf) {
  677.         if (sf == null) return false;
  678.         
  679.         switch (sf) {
  680.         case ABILITATO: return true;
  681.         case DISABILITATO: return false;
  682.         default: return false;
  683.         }
  684.     }
  685.     
  686.     public static final boolean statoFunzionalitaConfToBool(org.openspcoop2.core.config.constants.StatoFunzionalita sf) {
  687.         if (sf == null) return false;
  688.         
  689.         switch (sf) {
  690.         case ABILITATO: return true;
  691.         case DISABILITATO: return false;
  692.         default: return false;
  693.         }
  694.     }

  696.     
  697.     @Deprecated
  698.     public static final String boolToYesNo(boolean v) {
  699.         return ServletUtils.boolToCheckBoxStatus(v);
  700.     }
  701.     
  702.     public static final StatoFunzionalita boolToStatoFunzionalita(Boolean v) {
  703.         return v ? StatoFunzionalita.ABILITATO : StatoFunzionalita.DISABILITATO;
  704.     }
  705.     
  706.     public static final org.openspcoop2.core.config.constants.StatoFunzionalita boolToStatoFunzionalitaConf(Boolean v) {
  707.         if (v == null) v = false;
  708.         
  709.         return v ? org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO : org.openspcoop2.core.config.constants.StatoFunzionalita.DISABILITATO; 
  710.     }


  713.     public static final BinaryParameter toBinaryParameter(byte[] value) {
  714.         BinaryParameter ret = new BinaryParameter();
  715.         ret.setValue(value);
  716.         return ret;
  717.     }
  718.     
  719.     public static final AccordoServizioParteComune getAccordoFull(String nome, int versione, IDSoggetto idSoggReferente,    AccordiServizioParteComuneCore apcCore)  {
  720.         return evalnull( () -> apcCore.getAccordoServizioFull(IDAccordoFactory.getInstance().getIDAccordoFromValues(nome, idSoggReferente, versione)));
  721.     }
  722.     
  723.     public static final AccordoServizioParteComuneSintetico getAccordoSintetico(String nome, int versione, IDSoggetto idSoggReferente,  AccordiServizioParteComuneCore apcCore)  {
  724.         return evalnull( () -> apcCore.getAccordoServizioSintetico(IDAccordoFactory.getInstance().getIDAccordoFromValues(nome, idSoggReferente, versione)));
  725.     }

  727.     public static final ServiceBinding toManifestServiceBinding(
  728.             org.openspcoop2.core.registry.constants.ServiceBinding serviceBinding) {

  730.         switch(serviceBinding) {
  731.         case REST:
  732.             return ServiceBinding.REST;
  733.         case SOAP:
  734.             return ServiceBinding.SOAP;
  735.         default:
  736.             return null;
  737.         }
  738.             
  739.     }
  740.     
  741.     public static void setContentType(IContext context, String fileName) throws UtilsException {
  742.         String mimeType = null;
  743.         if(fileName.contains(".")){
  744.             String ext = null;
  745.             try{
  746.                 ext = fileName.substring(fileName.lastIndexOf(".")+1,fileName.length());
  747.             }catch(Exception e){
  748.                 // ignore
  749.             }
  750.             MimeTypes mimeTypes = MimeTypes.getInstance();
  751.             if(ext!=null && mimeTypes.existsExtension(ext)){
  752.                 mimeType = mimeTypes.getMimeType(ext);
  753.                 //System.out.println("CUSTOM ["+mimeType+"]");      
  754.             }
  755.             else{
  756.                 mimeType = HttpConstants.CONTENT_TYPE_X_DOWNLOAD;
  757.             }
  758.         }
  759.         else{
  760.             mimeType = HttpConstants.CONTENT_TYPE_X_DOWNLOAD;
  761.         }
  762.         
  763.         context.getServletResponse().setContentType(mimeType);
  764.     }

  766.     public static boolean isAppId(Boolean appIdObject) {
  767.         boolean appId = false;
  768.         if(appIdObject!=null) {
  769.             appId = appIdObject;
  770.         }
  771.         return appId;
  772.     }
  773. }
Created with JaCoCo 0.8.8.202204050719