MapProperties.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.utils.properties;


  26. import java.io.File;
  27. import java.io.Reader;
  28. import java.io.StringReader;
  29. import java.security.MessageDigest;
  30. import java.util.ArrayList;
  31. import java.util.List;
  32. import java.util.Properties;

  34. import org.apache.commons.lang.StringUtils;
  35. import org.openspcoop2.utils.LoggerWrapperFactory;
  36. import org.openspcoop2.utils.SortedMap;
  37. import org.openspcoop2.utils.Utilities;
  38. import org.openspcoop2.utils.UtilsException;
  39. import org.openspcoop2.utils.io.Base64Utilities;
  40. import org.openspcoop2.utils.resources.Charset;
  41. import org.openspcoop2.utils.resources.FileSystemUtilities;
  42. import org.slf4j.Logger;


  45. /**
  46.  * MapProperties
  47.  *
  48.  * @author Poli Andrea (apoli@link.it)
  49.  * @author $Author$
  50.  * @version $Rev$, $Date$
  51.  */


  54. public class MapProperties {    

  56.     public static final String FILE_NAME = "govway.map.properties";
  57.     
  58.     public static final String ENV_PREFIX = "env.";
  59.     public static final String JAVA_PREFIX = "java.";
  60.     
  61.     public static final String OBFUSCATED_ENV_KEYS = "obfuscated.env.keys";
  62.     public static final String OBFUSCATED_JAVA_KEYS = "obfuscated.java.keys";
  63.     
  64.     public static final String OBFUSCATED_MODE = "obfuscated.mode";
  65.     public static final String OBFUSCATED_MODE_NON_INIZIALIZZATO = "not initialized";
  66.     public static final String OBFUSCATED_MODE_NONE = "none";
  67.     public static final String OBFUSCATED_MODE_DIGEST = "digest";
  68.     public static final String OBFUSCATED_MODE_STATIC = "static";
  69.     
  70.     public static final String OBFUSCATED_DIGEST = "obfuscated.digest";
  71.     public static final String OBFUSCATED_DIGEST_DEFAULT = "SHA-256";
  72.     
  73.     public static final String OBFUSCATED_STATIC = "obfuscated.static";
  74.     public static final String OBFUSCATED_STATIC_DEFAULT = "******";
  75.     
  76.     
  77.     
  78.     
  79.     /** Logger utilizzato per errori eventuali. */
  80.     protected Logger log = null;



  84.     /* ********  F I E L D S  P R I V A T I  ******** */

  86.     /** Reader delle proprieta' impostate nel file 'govway.map.properties' */
  87.     protected PropertiesReader reader;
  88.     protected String content;

  90.     /** Copia Statica */
  91.     private static MapProperties mapProperties = null;

  93.     /** Variabili impostate */
  94.     protected SortedMap<String> envMap = new SortedMap<>();
  95.     protected SortedMap<String> javaMap = new SortedMap<>();
  96.     public SortedMap<String> getEnvMap() {
  97.         return this.envMap;
  98.     }
  99.     public SortedMap<String> getJavaMap() {
  100.         return this.javaMap;
  101.     }
  102.     

  104.     /* ********  C O S T R U T T O R E  ******** */

  106.     /**
  107.      * Viene chiamato in causa per istanziare il properties reader
  108.      *
  109.      * 
  110.      */
  111.     /**private MapProperties(Logger log, boolean throwNotFound) throws UtilsException {
  112.         init(log, FILE_NAME, throwNotFound);
  113.     }*/
  114.     protected MapProperties(Logger log, String fileName, boolean throwNotFound) throws UtilsException {
  115.         init(log, fileName, throwNotFound);
  116.     }
  117.     protected void init(Logger log, String fileName, boolean throwNotFound) throws UtilsException {

  119.         if(log==null) {
  120.             this.log = LoggerWrapperFactory.getLogger(MapProperties.class);
  121.         }
  122.         else {
  123.             this.log = log;
  124.         }
  125.         
  126.         /* ---- Lettura del cammino del file di configurazione ---- */
  127.         Properties propertiesReader = readProperties(fileName);
  128.         
  129.         if(propertiesReader!=null) {
  130.             this.reader = new PropertiesReader(propertiesReader, true);
  131.         }
  132.         else if(throwNotFound){
  133.             throw new UtilsException("Config '"+fileName+"' not found");
  134.         }
  135.         
  136.     }
  137.     private Properties readProperties(String fileName) throws UtilsException {
  138.         File fCheck = new File(fileName);
  139.         if(fCheck.exists()) {
  140.             if(!fCheck.canRead()) {
  141.                 throw new UtilsException("File '"+fCheck.getAbsolutePath()+"' cannot read");
  142.             }
  143.             try{
  144.                 this.content = FileSystemUtilities.readFile(fCheck);
  145.             }catch(Exception e) {
  146.                 throw new UtilsException("File '"+fCheck.getAbsolutePath()+"' read failed: "+e.getMessage(),e);
  147.             }
  148.         }
  149.         else {
  150.             String uri = fileName;
  151.             if(!fileName.startsWith("/")) {
  152.                 uri = "/" + fileName;
  153.             }
  154.             try(java.io.InputStream properties = MapProperties.class.getResourceAsStream(uri)){
  155.                 if(properties!=null) {
  156.                     this.content = Utilities.getAsString(properties, Charset.UTF_8.getValue());
  157.                 }
  158.             }catch(Exception e) {
  159.                 throw new UtilsException("Uri '"+uri+"' access failed: "+e.getMessage(),e);
  160.             }
  161.         }
  162.         
  163.         Properties props = null;
  164.         if(this.content!=null) {
  165.             props = new Properties();
  166.             try(Reader properties = new StringReader(this.content)){
  167.                 props.load(properties);
  168.             }catch(Exception e) {
  169.                 throw new UtilsException("Config '"+fileName+"' access failed: "+e.getMessage(),e);
  170.             }
  171.         }
  172.         
  173.         return props;
  174.     }


  177.     /**
  178.      * Il Metodo si occupa di inizializzare il propertiesReader 
  179.      *
  180.      * 
  181.      */
  182.     public static boolean initialize(Logger log, String fileName, boolean throwNotFound){

  184.         try {
  185.             MapProperties.mapProperties = new MapProperties(log, fileName, throwNotFound);  
  186.             return true;
  187.         }
  188.         catch(Exception e) {
  189.             return false;
  190.         }
  191.     }
  192.     
  193.     /**
  194.      * Ritorna l'istanza di questa classe
  195.      *
  196.      * @return Istanza di MapProperties
  197.      * 
  198.      */
  199.     public static MapProperties getInstance(){
  200.         // spotbugs warning 'SING_SINGLETON_GETTER_NOT_SYNCHRONIZED': l'istanza viene creata allo startup
  201.         if (MapProperties.mapProperties == null) {
  202.             synchronized (MapProperties.class) {
  203.                 if (MapProperties.mapProperties == null) {
  204.                     return null;
  205.                 }
  206.             }
  207.         }
  208.         return MapProperties.mapProperties;
  209.     }
  210.     
  211.     
  212.     public void initEnvironment() throws UtilsException {   
  213.         if(this.content!=null) {
  214.             SortedMap<String> convertTextToProperties = PropertiesUtilities.convertTextToSortedMap(this.content, false);
  215.             if(convertTextToProperties!=null && !convertTextToProperties.isEmpty()) {
  216.                 List<String> keys = convertTextToProperties.keys();
  217.                 if(keys!=null && !keys.isEmpty()) {
  218.                     for (String key : keys) {
  219.                         loadPropertyInEnvironment(key);
  220.                     }
  221.                 }
  222.             }
  223.         }
  224.     }
  225.     
  226.     public void loadPropertyInEnvironment(String key) throws UtilsException {
  227.         if(key.startsWith(ENV_PREFIX) && key.length()>ENV_PREFIX.length()) {
  228.             String envKey = key.substring(ENV_PREFIX.length());
  229.             String value = this.reader.getValue_convertEnvProperties(key);
  230.             setEnvProperty(envKey, value);
  231.         }
  232.         else if(key.startsWith(JAVA_PREFIX) && key.length()>JAVA_PREFIX.length()) {
  233.             String envKey = key.substring(JAVA_PREFIX.length());
  234.             String value = this.reader.getValue_convertEnvProperties(key);
  235.             setJavaProperty(envKey, value);
  236.         }
  237.     }

  239.     protected void setJavaProperty(String envKey, String value) throws UtilsException {
  240.         if(value!=null) {
  241.             System.setProperty(envKey, value);
  242.             
  243.             // per preservare l'ordine
  244.             if(this.javaMap.containsKey(envKey)) {
  245.                 this.javaMap.remove(envKey);
  246.             }
  247.             this.javaMap.put(envKey, value);
  248.             /**System.out.println("---- JAVAP ["+envKey+"]=["+value+"]");*/
  249.         }
  250.     }
  251.     
  252.     protected void setEnvProperty(String envKey, String value) throws UtilsException {
  253.         if(value!=null) {
  254.             Utilities.setEnvProperty(envKey, value);
  255.             
  256.             // per preservare l'ordine
  257.             if(this.envMap.containsKey(envKey)) {
  258.                 this.envMap.remove(envKey);
  259.             }
  260.             this.envMap.put(envKey, value);
  261.             /**System.out.println("---- ENVP ["+envKey+"]=["+value+"]");*/
  262.         }
  263.     }
  264.     
  265.     public List<String> getObfuscatedEnvKeys() throws UtilsException{
  266.         return getObfuscatedKeys(OBFUSCATED_ENV_KEYS);
  267.     }
  268.     public List<String> getObfuscatedJavaKeys() throws UtilsException{
  269.         return getObfuscatedKeys(OBFUSCATED_JAVA_KEYS);
  270.     }
  271.     private List<String> getObfuscatedKeys(String pName) throws UtilsException{
  272.         List<String> l = new ArrayList<>();
  273.         if(this.reader==null) {
  274.             return l; // non inizializzato
  275.         }
  276.         if(isObfuscatedModeEnabled()) {
  277.             String value = this.reader.getValue_convertEnvProperties(pName);
  278.             if(value!=null && StringUtils.isNotEmpty(value.trim())) {
  279.                 value = value.trim();
  280.                 if(value.contains(",")) {
  281.                     fillObfuscatedKeys(value, l);
  282.                 }
  283.                 else {
  284.                     l.add(value);
  285.                 }
  286.             }
  287.         }
  288.         return l;
  289.     }
  290.     private void fillObfuscatedKeys(String value, List<String> l) {
  291.         String [] tmp = value.split(",");
  292.         if(tmp!=null && tmp.length>0) {
  293.             for (String t : tmp) {
  294.                 if(t!=null && StringUtils.isNotEmpty(t.trim())) {
  295.                     l.add(t);
  296.                 }
  297.             }
  298.         }
  299.     }
  300.     
  301.     public boolean isObfuscatedModeEnabled() throws UtilsException {
  302.         if(this.reader==null) {
  303.             return false; // non inizializzato
  304.         }
  305.         String value = this.reader.getValue_convertEnvProperties(OBFUSCATED_MODE);
  306.         if(value!=null && StringUtils.isNotEmpty(value.trim())) {
  307.             value = value.trim();
  308.             if(OBFUSCATED_MODE_DIGEST.equals(value) || (OBFUSCATED_MODE_STATIC.equals(value))) {
  309.                  return true;
  310.             }
  311.             else if(OBFUSCATED_MODE_NONE.equals(value)) {
  312.                 return false;
  313.             }
  314.             else {
  315.                 throw new UtilsException("["+OBFUSCATED_MODE+"] unknown mode '"+value+"'");
  316.             }
  317.         }
  318.         else {
  319.             return true; // default
  320.         }
  321.     }
  322.     
  323.     public String getObfuscateModeDescription() throws UtilsException {
  324.         if(this.reader==null) {
  325.             return OBFUSCATED_MODE_NON_INIZIALIZZATO; // non inizializzato
  326.         }
  327.         String obfuscateMode = OBFUSCATED_MODE_NONE;
  328.         if(this.isObfuscatedModeStatic()) {
  329.             obfuscateMode = OBFUSCATED_MODE_STATIC+" ("+this.getObfuscatedModeStaticValue()+")";
  330.         }
  331.         else if(this.isObfuscatedModeDigest()) {
  332.             obfuscateMode = OBFUSCATED_MODE_DIGEST+" ("+this.getObfuscatedModeDigestAlgo()+")";
  333.         }
  334.         return obfuscateMode;
  335.     }   
  336.     
  337.     public boolean isObfuscatedModeStatic() throws UtilsException {
  338.         return getObfuscatedModeStaticValue()!=null;
  339.     }
  340.     public String getObfuscatedModeStaticValue() throws UtilsException {
  341.         if(this.reader==null) {
  342.             return null; // non inizializzato
  343.         }
  344.         String value = this.reader.getValue_convertEnvProperties(OBFUSCATED_MODE);
  345.         if(value!=null && StringUtils.isNotEmpty(value.trim())) {
  346.             value = value.trim();
  347.             if(OBFUSCATED_MODE_STATIC.equals(value)) {
  348.                 String s = this.reader.getValue_convertEnvProperties(OBFUSCATED_STATIC);
  349.                 if(s!=null && StringUtils.isNotEmpty(s.trim())) {
  350.                     return s.trim();
  351.                 }
  352.                 else {
  353.                     return OBFUSCATED_STATIC_DEFAULT; // default
  354.                 }
  355.             }
  356.             else if(OBFUSCATED_MODE_DIGEST.equals(value) || (OBFUSCATED_MODE_NONE.equals(value))) {
  357.                 return null;
  358.             }
  359.             else {
  360.                 throw new UtilsException("["+OBFUSCATED_MODE+"] unknown property value '"+value+"'");
  361.             }
  362.         }
  363.         else {
  364.             return null; 
  365.         }
  366.     }
  367.     
  368.     public boolean isObfuscatedModeDigest() throws UtilsException {
  369.         return getObfuscatedModeDigestAlgo()!=null;
  370.     }
  371.     public String getObfuscatedModeDigestAlgo() throws UtilsException {
  372.         if(this.reader==null) {
  373.             return null; // non inizializzato
  374.         }
  375.         String value = this.reader.getValue_convertEnvProperties(OBFUSCATED_MODE);
  376.         if(value!=null && StringUtils.isNotEmpty(value.trim())) {
  377.             value = value.trim();
  378.             if(OBFUSCATED_MODE_DIGEST.equals(value)) {
  379.                 String s = this.reader.getValue_convertEnvProperties(OBFUSCATED_DIGEST);
  380.                 if(s!=null && StringUtils.isNotEmpty(s.trim())) {
  381.                     return s.trim();
  382.                 }
  383.                 else {
  384.                     return OBFUSCATED_DIGEST_DEFAULT; // default
  385.                 }
  386.             }
  387.             else if(OBFUSCATED_MODE_STATIC.equals(value) || (OBFUSCATED_MODE_NONE.equals(value))) {
  388.                 return null;
  389.             }
  390.             else {
  391.                 throw new UtilsException("["+OBFUSCATED_MODE+"] unknown property value '"+value+"'");
  392.             }
  393.         }
  394.         else {
  395.             return OBFUSCATED_DIGEST_DEFAULT; // default
  396.         }
  397.     }

  399.     protected boolean obfuscate(boolean java, String key) {
  400.         if(java || key!=null) {
  401.             // parametri forniti nel caso venga re-implementato il metodo
  402.         }
  403.         return true;
  404.     }
  405.     
  406.     public String obfuscateJavaProperty(String key, String value) throws UtilsException {
  407.         return obfuscate(true, key, value);
  408.     }
  409.     public String obfuscateEnvProperty(String key, String value) throws UtilsException {
  410.         return obfuscate(false, key, value);
  411.     }
  412.     protected String obfuscate(boolean java, String key, String value) throws UtilsException {
  413.         if(!this.obfuscate(java, key)) {
  414.             return value;
  415.         }
  416.         if(!isObfuscatedModeEnabled() || value==null || StringUtils.isEmpty(value)) {
  417.             return value;
  418.         }
  419.         if(this.isObfuscatedModeStatic()) {
  420.             return this.getObfuscatedModeStaticValue();
  421.         }
  422.         else if(this.isObfuscatedModeDigest()) {
  423.             try {
  424.                 return Base64Utilities.encodeAsString(MessageDigest.getInstance(this.getObfuscatedModeDigestAlgo()).digest(value.getBytes()));
  425.             }catch(Exception e) {
  426.                 throw new UtilsException(e.getMessage(),e);
  427.             }
  428.         }
  429.         else {
  430.             throw new UtilsException("["+OBFUSCATED_MODE+"] unsupported mode");
  431.         }
  432.     }
  433.     
  434.     public static String obfuscateByDigest(String value) throws UtilsException {
  435.         try {
  436.             return Base64Utilities.encodeAsString(MessageDigest.getInstance(OBFUSCATED_DIGEST_DEFAULT).digest(value.getBytes()));
  437.         }catch(Exception e) {
  438.             throw new UtilsException(e.getMessage(),e);
  439.         }
  440.     }
  441. }
Created with JaCoCo 0.8.8.202204050719