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

  21. package org.openspcoop2.pdd.config.vault.cli;

  23. import java.io.File;
  24. import java.io.InputStream;
  25. import java.util.HashMap;
  26. import java.util.Map;
  27. import java.util.Properties;

  29. import org.apache.commons.lang.StringUtils;
  30. import org.openspcoop2.core.commons.CoreException;
  31. import org.openspcoop2.core.config.driver.ExtendedInfoManager;
  32. import org.openspcoop2.pdd.core.byok.BYOKMapProperties;
  33. import org.openspcoop2.pdd.core.dynamic.DynamicInfo;
  34. import org.openspcoop2.pdd.core.dynamic.DynamicUtils;
  35. import org.openspcoop2.pdd.services.ServicesUtils;
  36. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  37. import org.openspcoop2.protocol.sdk.ConfigurazionePdD;
  38. import org.openspcoop2.utils.LoggerWrapperFactory;
  39. import org.openspcoop2.utils.certificate.byok.BYOKManager;
  40. import org.openspcoop2.utils.certificate.hsm.HSMManager;
  41. import org.openspcoop2.utils.certificate.hsm.HSMUtils;
  42. import org.openspcoop2.utils.properties.MapProperties;
  43. import org.openspcoop2.utils.security.ProviderUtils;
  44. import org.slf4j.Logger;

  46. /**
  47.  *  VaultTools
  48.  *
  49.  * @author Poli Andrea (apoli@link.it)
  50.  * @author $Author$
  51.  * @version $Rev$, $Date$
  52.  */
  53. public class VaultTools {

  55.     private static Logger logCore = LoggerWrapperFactory.getLogger(VaultTools.class);
  56.     public static Logger getLogCore() {
  57.         return logCore;
  58.     }
  59.     public static void logCoreDebug(String msg) {
  60.         logCore.debug(msg);
  61.     }
  62.     public static void logCoreInfo(String msg) {
  63.         logCore.info(msg);
  64.     }
  65.     public static void logCoreError(String msg, Exception e) {
  66.         logCore.error(msg,e);
  67.     }
  68.     private static Logger logOutput = LoggerWrapperFactory.getLogger(VaultTools.class);
  69.     public static void logOutput(String msg) {
  70.         logOutput.info(msg);
  71.     }
  72.     
  73.     public static void main(String[] args) throws CoreException {
  74.         
  75.         VaultOperationType opType = null;
  76.         VaultUpdateConfig updateConfig = null;
  77.         VaultEncDecConfig encDecConfig = null;
  78.         String[] argsConfig = null;
  79.         String utilizzoErrato = null;
  80.         try {
  81.         
  82.             // Logger
  83.             initLogger();
  84.             logCore=LoggerWrapperFactory.getLogger("govway_vault.core");    
  85.             logOutput=LoggerWrapperFactory.getLogger("govway_vault.output");    
  86.             
  87.             
  88.             logCoreDebug("Raccolta parametri in corso...");
  89.                                     
  90.             // args
  91.             utilizzoErrato = "Usage error: VaultTools <operationType> <options>\n"+
  92.                     "- <operationType>: "+VaultOperationType.UPDATE_CONFIG.getValue()+","+VaultOperationType.ENCRYPT.getValue()+","+VaultOperationType.DECRYPT.getValue()+"\n"+
  93.                     "- <options>: \n"+
  94.                     "\t- "+VaultOperationType.UPDATE_CONFIG.getValue()+": "+VaultUpdateConfig.getUsage()+"\n"+
  95.                     "\t- "+VaultOperationType.ENCRYPT.getValue()+": "+VaultEncDecConfig.getUsage()+"\n"+
  96.                     "\t- "+VaultOperationType.DECRYPT.getValue()+": "+VaultEncDecConfig.getUsage()+"";
  97.             
  98.         }
  99.         catch(Exception t) {
  100.             if(logCore!=null) {
  101.                 logCore.error(t.getMessage(),t);
  102.             }
  103.             throw new CoreException(t.getMessage(),t);
  104.         }
  105.             
  106.         if(args.length<1 || args[0]==null) {
  107.             throw new CoreException(utilizzoErrato);
  108.         }
  109.         
  110.         try {
  111.             opType = parseOperationType(utilizzoErrato, args);
  112.             argsConfig = new String[args.length - 1];
  113.             System.arraycopy(args, 1, argsConfig, 0, args.length - 1);
  114.         }
  115.         catch(Exception t) {
  116.             if(logCore!=null) {
  117.                 logCore.error(t.getMessage(),t);
  118.             }
  119.             throw new CoreException(t.getMessage(),t);
  120.         }
  121.         
  122.         switch (opType) {
  123.         case UPDATE_CONFIG:
  124.             utilizzoErrato = "Usage error: update "+VaultUpdateConfig.getUsage();           
  125.             updateConfig = new VaultUpdateConfig(argsConfig, utilizzoErrato);
  126.             break;
  127.         case ENCRYPT:
  128.             utilizzoErrato = "Usage error: encrypt "+VaultEncDecConfig.getUsage();          
  129.             encDecConfig = new VaultEncDecConfig(argsConfig, utilizzoErrato, true);
  130.             break;
  131.         case DECRYPT:
  132.             utilizzoErrato = "Usage error: decrypt "+VaultEncDecConfig.getUsage();          
  133.             encDecConfig = new VaultEncDecConfig(argsConfig, utilizzoErrato, false);
  134.             break;
  135.         }
  136.         
  137.         try {
  138.             process(updateConfig, encDecConfig);
  139.         }
  140.         catch(Exception t) {
  141.             if(logCore!=null) {
  142.                 logCore.error(t.getMessage(),t);
  143.             }
  144.             throw new CoreException(t.getMessage(),t);
  145.         }

  147.     }
  148.     
  149.     private static void process(VaultUpdateConfig updateConfig, VaultEncDecConfig encDecConfig) throws CoreException {
  150.         logCoreDebug("Raccolta parametri terminata");
  151.         
  152.         // properties
  153.         VaultProperties vaultProperties = VaultProperties.getInstance();
  154.         /**String confDir = null;*/ // non sembra servire
  155.         String protocolloDefault = vaultProperties.getProtocolloDefault();
  156.         
  157.         // Inizializzo Controlli connessioni
  158.         disableCheckSingleConnectionDataSource();
  159.         
  160.         // Map (environment)
  161.         initMap(vaultProperties);
  162.         
  163.         // Load Security Provider
  164.         if(vaultProperties.isSecurityLoadBouncyCastleProvider()) {
  165.             initBouncyCastle();
  166.         }
  167.         
  168.         // inizializzo HSM Manager
  169.         initHsm(vaultProperties);
  170.         
  171.         // inizializzo BYOK Manager
  172.         BYOKManager byokManager = initBYOK(vaultProperties);
  173.         
  174.         // Secrets (environment)
  175.         initSecrets(vaultProperties, byokManager);
  176.         
  177.         // Init GovWay
  178.         logCoreDebug("Inizializzazione risorse libreria in corso...");
  179.         
  180.         initProtocolFactory(protocolloDefault);
  181.         
  182.         initExtendedInfoManager();
  183.         
  184.         logCoreDebug("Inizializzazione risorse libreria terminata");
  185.         
  186.         // Validazione configurazioni
  187.         if(updateConfig!=null) {
  188.             
  189.             logCoreInfo("Aggiornamento informazioni sensibili in corso ...");
  190.             
  191.             updateConfig.validate(byokManager);
  192.             VaultUpdateConfigUtilities utils = new VaultUpdateConfigUtilities(updateConfig);
  193.             utils.process();
  194.             
  195.             logCoreInfo("Aggiornamento informazioni sensibili completato");
  196.         }
  197.         else if(encDecConfig!=null) {
  198.             
  199.             String op = encDecConfig.isEncode() ? "Cifratura" : "Decrifratura";
  200.             logCoreInfo(op+" in corso ...");
  201.             
  202.             encDecConfig.validate(byokManager);
  203.             VaultEncDecUtilities utils = new VaultEncDecUtilities(encDecConfig);
  204.             utils.process();
  205.             
  206.             logCoreInfo(op+" completata");
  207.         }
  208.     }

  210.     private static void initLogger() throws CoreException {
  211.         Properties propertiesLog4j = new Properties();
  212.         try (InputStream inPropLog4j = VaultTools.class.getResourceAsStream("/govway_vault.cli.log4j2.properties");){
  213.             propertiesLog4j.load(inPropLog4j);
  214.             LoggerWrapperFactory.setLogConfiguration(propertiesLog4j);
  215.         } catch(java.lang.Exception e) {
  216.             throw new CoreException("Impossibile leggere i dati dal file 'govway_vault.cli.log4j2.properties': "+e.getMessage());
  217.         } 
  218.     }
  219.     private static VaultOperationType parseOperationType(String utilizzoErrato,String [] args) throws CoreException{
  220.         VaultOperationType opType = null;
  221.         try {
  222.             opType = VaultOperationType.toEnumConstant(args[0].trim(), true);
  223.         }catch(Exception e) {
  224.             throw new CoreException(utilizzoErrato+"\nIl tipo di operazione indicato ("+args[0].trim()+") non รจ gestito, valori ammessi: "+
  225.                     VaultOperationType.UPDATE_CONFIG.getValue()+","+VaultOperationType.ENCRYPT.getValue()+","+VaultOperationType.DECRYPT.getValue());
  226.         }
  227.         return opType;
  228.     }
  229.     private static void initBouncyCastle() throws CoreException {
  230.         try{
  231.             ProviderUtils.addBouncyCastleAfterSun(true);
  232.             logCoreInfo("Aggiunto Security Provider org.bouncycastle.jce.provider.BouncyCastleProvider");
  233.         }catch(Exception e){
  234.             throw new CoreException(e.getMessage(),e);
  235.         }
  236.     }
  237.     private static void disableCheckSingleConnectionDataSource() throws CoreException {
  238.         // Inizializzo Controlli connessioni
  239.         try {
  240.             Logger logR = logCore;
  241.             ServicesUtils.initCheckConnectionDB(logR, false, false);
  242.         } catch (Exception e) {
  243.             doError("Inizializzazione controlli connessione non riuscita",e);
  244.         }
  245.     }
  246.     private static void initMap(VaultProperties loaderProperties) throws CoreException {
  247.         try {
  248.             String mapConfig = loaderProperties.getEnvMapConfig();
  249.             if(StringUtils.isNotEmpty(mapConfig)) {
  250.                 logCoreInfo("Inizializzazione environment in corso...");
  251.                 MapProperties.initialize(logCore, mapConfig, loaderProperties.isEnvMapConfigRequired());
  252.                 MapProperties mapProperties = MapProperties.getInstance();
  253.                 mapProperties.initEnvironment();
  254.                 String msgInit = "Environment inizializzato con le variabili definite nel file '"+mapConfig+"'"+
  255.                         "\n\tJavaProperties: "+mapProperties.getJavaMap().keys()+
  256.                         "\n\tEnvProperties: "+mapProperties.getEnvMap().keys()+
  257.                         "\n\tObfuscateMode: "+mapProperties.getObfuscateModeDescription()+
  258.                         "\n\tObfuscatedJavaKeys: "+mapProperties.getObfuscatedJavaKeys()+
  259.                         "\n\tObfuscatedEnvKeys: "+mapProperties.getObfuscatedEnvKeys();
  260.                 logCoreInfo(msgInit);
  261.             }
  262.         } catch (Exception e) {
  263.             doError("Errore durante l'inizializzazione dell'ambiente",e);
  264.         }
  265.     }
  266.     private static void initHsm(VaultProperties loaderProperties) throws CoreException {
  267.         // inizializzo HSM Manager
  268.         try {
  269.             String hsmConfig = loaderProperties.getHSMConfigurazione();
  270.             if(StringUtils.isNotEmpty(hsmConfig)) {
  271.                 logCoreInfo("Inizializzazione HSM in corso...");
  272.                 File f = new File(hsmConfig);
  273.                 HSMManager.init(f, loaderProperties.isHSMRequired(), logCore, false);
  274.                 HSMUtils.setHsmConfigurableKeyPassword(loaderProperties.isHSMKeyPasswordConfigurable());
  275.                 logCoreInfo("Inizializzazione HSM effettuata con successo");
  276.             }
  277.         } catch (Exception e) {
  278.             doError("Errore durante l'inizializzazione del manager HSM",e);
  279.         }
  280.     }
  281.     private static BYOKManager initBYOK(VaultProperties loaderProperties) throws CoreException {
  282.         BYOKManager byokManager = null;
  283.         try {
  284.             String byokConfig = loaderProperties.getBYOKConfigurazione();
  285.             if(StringUtils.isNotEmpty(byokConfig)) {
  286.                 logCoreInfo("Inizializzazione BYOK in corso...");
  287.                 File f = new File(byokConfig);
  288.                 BYOKManager.init(f, loaderProperties.isBYOKRequired(), logCore);
  289.                 byokManager = BYOKManager.getInstance();
  290.                 String msgInit = "Gestore BYOK inizializzato;"+
  291.                         "\n\tHSM registrati: "+byokManager.getKeystoreTypes()+
  292.                         "\n\tSecurityEngine registrati: "+byokManager.getSecurityEngineTypes()+
  293.                         "\n\tGovWaySecurityEngine: "+byokManager.getSecurityEngineGovWayDescription();
  294.                 logCoreInfo(msgInit);
  295.             }
  296.         } catch (Exception e) {
  297.             doError("Errore durante l'inizializzazione del manager BYOK",e);
  298.         }
  299.         return byokManager;
  300.     }
  301.     private static void initSecrets(VaultProperties loaderProperties, BYOKManager byokManager) throws CoreException {
  302.         try {
  303.             String secretsConfig = loaderProperties.getBYOKEnvSecretsConfig();
  304.             if(byokManager!=null && StringUtils.isNotEmpty(secretsConfig)) {
  305.                 logCoreInfo("Inizializzazione secrets in corso...");
  306.                 
  307.                 Map<String, Object> dynamicMap = new HashMap<>();
  308.                 DynamicInfo dynamicInfo = new  DynamicInfo();
  309.                 DynamicUtils.fillDynamicMap(logCore, dynamicMap, dynamicInfo);
  310.                 
  311.                 BYOKMapProperties.initialize(logCore, secretsConfig, loaderProperties.isBYOKEnvSecretsConfigRequired(), 
  312.                         true, 
  313.                         dynamicMap, true);
  314.                 BYOKMapProperties secretsProperties = BYOKMapProperties.getInstance();
  315.                 secretsProperties.initEnvironment();
  316.                 String msgInit = "Environment inizializzato con i secrets definiti nel file '"+secretsConfig+"'"+
  317.                         "\n\tJavaProperties: "+secretsProperties.getJavaMap().keys()+
  318.                         "\n\tEnvProperties: "+secretsProperties.getEnvMap().keys()+
  319.                         "\n\tObfuscateMode: "+secretsProperties.getObfuscateModeDescription();
  320.                 logCoreInfo(msgInit);
  321.             }
  322.         } catch (Exception e) {
  323.             doError("Errore durante l'inizializzazione dell'ambiente (secrets)",e);
  324.         }   
  325.     }
  326.     private static ConfigurazionePdD initProtocolFactory(String protocolloDefault) throws CoreException {
  327.         ConfigurazionePdD configPdD = null;
  328.         try {
  329.             configPdD = new ConfigurazionePdD();
  330.             configPdD.setAttesaAttivaJDBC(-1);
  331.             configPdD.setCheckIntervalJDBC(-1);
  332.             configPdD.setLoader(new org.openspcoop2.utils.resources.Loader(VaultTools.class.getClassLoader()));
  333.             configPdD.setLog(logCore);
  334.             ProtocolFactoryManager.initialize(logCore, configPdD,
  335.                     protocolloDefault);
  336.         } catch (Exception e) {
  337.             throw new CoreException("Errore (InitConfigurazione - ProtocolFactoryManager): "+e.getMessage(),e);
  338.         }
  339.         return configPdD;
  340.     }
  341.     private static void initExtendedInfoManager() throws CoreException {
  342.         try{
  343.             ExtendedInfoManager.initialize(new org.openspcoop2.utils.resources.Loader(VaultTools.class.getClassLoader()), null, null, null);
  344.         }catch(Exception e){
  345.             throw new CoreException("Inizializzazione [ExtendedInfoManager] fallita",e);
  346.         }
  347.     }

  349.     private static void doError(String msg,Exception e) throws CoreException {
  350.         String msgErrore = msg+": " + e.getMessage();
  351.         logCoreError(msgErrore,e);
  352.         throw new CoreException(msgErrore,e);
  353.     }
  354.     
  355. }
Created with JaCoCo 0.8.8.202204050719