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


  22. package org.openspcoop2.security.message.utils;

  24. import java.util.List;
  25. import java.util.Map;
  26. import java.util.Properties;

  28. import org.openspcoop2.core.commons.DBUtils;
  29. import org.openspcoop2.core.mvc.properties.Item;
  30. import org.openspcoop2.core.mvc.properties.constants.ItemType;
  31. import org.openspcoop2.core.mvc.properties.provider.IProvider;
  32. import org.openspcoop2.core.mvc.properties.provider.ProviderException;
  33. import org.openspcoop2.core.mvc.properties.provider.ProviderValidationException;
  34. import org.openspcoop2.security.message.constants.SecurityConstants;
  35. import org.openspcoop2.utils.UtilsRuntimeException;
  36. import org.openspcoop2.utils.certificate.KeystoreType;
  37. import org.openspcoop2.utils.certificate.byok.BYOKProvider;
  38. import org.openspcoop2.utils.certificate.hsm.HSMUtils;
  39. import org.openspcoop2.utils.certificate.ocsp.OCSPProvider;

  41. /**     
  42.  * AbstractSecurityProvider
  43.  *
  44.  * @author Poli Andrea (poli@link.it)
  45.  * @author $Author$
  46.  * @version $Rev$, $Date$
  47.  */
  48. public abstract class AbstractSecurityProvider implements IProvider {

  50.     private boolean asTruststore = false; // indicazione se questo provider serve per un keystore o truststore
  51.     
  52.     public boolean isAsTruststore() {
  53.         return this.asTruststore;
  54.     }
  55.     public void useAsKeystore() {
  56.         this.asTruststore = false;
  57.     }
  58.     public void useAsTruststore() {
  59.         this.asTruststore = true;
  60.     }
  61.     
  62.     private OCSPProvider ocspProvider;
  63.     private BYOKProvider byokProvider;

  65.     protected AbstractSecurityProvider() {
  66.         this.ocspProvider = new OCSPProvider();
  67.         try {
  68.             this.byokProvider = BYOKProvider.getUnwrapInstance();
  69.         }catch(Exception e) {
  70.             throw new UtilsRuntimeException(e.getMessage(),e);
  71.         }
  72.     }
  73.     
  74.     
  75.     @Override
  76.     public void validate(Map<String, Properties> mapProperties) throws ProviderException, ProviderValidationException {

  78.     }

  80.     @Override
  81.     public List<String> getValues(String id) throws ProviderException {
  82.         List<String> l = null;
  83.         if(SecurityConstants.KEYSTORE_TYPE.equals(id)) {
  84.             l = SecurityConstants.getTipologieKeystoreValues(this.asTruststore);
  85.         }
  86.         else if(SecurityConstants.SECRETKEYSTORE_TYPE.equals(id)) {
  87.             l = SecurityConstants.getTipologieSecretKeystoreValues();
  88.         }
  89.         else if(SecurityConstants.TRUSTSTORE_TYPE.equals(id)) {
  90.             l = SecurityConstants.getTipologieKeystoreValues(true);
  91.         }
  92.         else if(SecurityConstants.TRUSTSTORE_OCSP_POLICY.equals(id) ||
  93.                 SecurityConstants.KEYSTORE_OCSP_POLICY.equals(id)) {
  94.             l = this.ocspProvider.getValues();
  95.         }
  96.         else if(SecurityConstants.KEYSTORE_BYOK_POLICY.equals(id) ||
  97.                 SecurityConstants.SECRETKEYSTORE_BYOK_POLICY.equals(id)) {
  98.             l = this.byokProvider.getValues();
  99.         }
  100.         return l;
  101.     }

  103.     @Override
  104.     public List<String> getLabels(String id) throws ProviderException {
  105.         List<String> l = null;
  106.         if(SecurityConstants.KEYSTORE_TYPE.equals(id)) {
  107.             l = SecurityConstants.getTipologieKeystoreLabels(this.asTruststore);
  108.         }
  109.         else if(SecurityConstants.SECRETKEYSTORE_TYPE.equals(id)) {
  110.             l = SecurityConstants.getTipologieSecretKeystoreLabels();
  111.         }
  112.         else if(SecurityConstants.TRUSTSTORE_TYPE.equals(id)) {
  113.             l = SecurityConstants.getTipologieKeystoreLabels(true);
  114.         }
  115.         else if(SecurityConstants.TRUSTSTORE_OCSP_POLICY.equals(id) ||
  116.                 SecurityConstants.KEYSTORE_OCSP_POLICY.equals(id)) {
  117.             l = this.ocspProvider.getLabels();
  118.         }
  119.         else if(SecurityConstants.KEYSTORE_BYOK_POLICY.equals(id) ||
  120.                 SecurityConstants.SECRETKEYSTORE_BYOK_POLICY.equals(id)) {
  121.             l = this.byokProvider.getLabels();
  122.         }
  123.         else {
  124.             l = this.getValues(id);
  125.         }
  126.         return l;
  127.     }
  128.     
  129.     @Override
  130.     public String getDefault(String id) throws ProviderException {

  132.         return null;
  133.     }

  135.     @Override
  136.     public String dynamicUpdate(List<?> items, Map<String, String> mapNameValue, Item item, String actualValue) {
  137.         if(SecurityConstants.KEYSTORE_FILE.equals(item.getName()) || 
  138.                 SecurityConstants.SECRETKEYSTORE_FILE.equals(item.getName()) || 
  139.                 SecurityConstants.TRUSTSTORE_FILE.equals(item.getName())) {
  140.             return dynamicUpdateStoreFile(items, mapNameValue, item, actualValue);
  141.         }
  142.         else if(SecurityConstants.KEYSTORE_PASSWORD.equals(item.getName()) || 
  143.                 SecurityConstants.SECRETKEYSTORE_PASSWORD.equals(item.getName()) || 
  144.                 SecurityConstants.TRUSTSTORE_PASSWORD.equals(item.getName())) {
  145.             return dynamicUpdateStorePassword(items, mapNameValue, item, actualValue);          
  146.         }
  147.         else if(SecurityConstants.KEYSTORE_PRIVATE_KEY_PASSWORD.equals(item.getName()) ||
  148.                 SecurityConstants.SECRETKEYSTORE_PRIVATE_KEY_PASSWORD.equals(item.getName())) {
  149.             return dynamicUpdateStoreKeyPassword(items, mapNameValue, item, actualValue);
  150.         }
  151.         else if(SecurityConstants.TRUSTSTORE_OCSP_POLICY.equals(item.getName()) ||
  152.                 SecurityConstants.KEYSTORE_OCSP_POLICY.equals(item.getName())) {
  153.             if(!this.ocspProvider.isOcspEnabled()) {
  154.                 item.setValue("");
  155.                 item.setType(ItemType.HIDDEN);
  156.             }
  157.         }
  158.         else if(SecurityConstants.KEYSTORE_BYOK_POLICY.equals(item.getName()) ||
  159.                 SecurityConstants.SECRETKEYSTORE_BYOK_POLICY.equals(item.getName())) {
  160.             return dynamicUpdateByok(items, mapNameValue, item, actualValue);
  161.         }
  162.         
  163.         return actualValue;
  164.     }
  165.     private String dynamicUpdateStoreFile(List<?> items, Map<String, String> mapNameValue, Item item, String actualValue) {
  166.         String type = SecurityConstants.KEYSTORE_TYPE;
  167.         if(SecurityConstants.SECRETKEYSTORE_FILE.equals(item.getName())) {
  168.             type = SecurityConstants.SECRETKEYSTORE_TYPE;
  169.         }
  170.         else if(SecurityConstants.TRUSTSTORE_FILE.equals(item.getName())) {
  171.             type = SecurityConstants.TRUSTSTORE_TYPE;
  172.         }
  173.         
  174.         return processStoreFile(type, items, mapNameValue, item, actualValue);
  175.     }
  176.     private String dynamicUpdateStorePassword(List<?> items, Map<String, String> mapNameValue, Item item, String actualValue) {
  177.         String type = SecurityConstants.KEYSTORE_TYPE;
  178.         boolean keystore = true;
  179.         if(SecurityConstants.SECRETKEYSTORE_PASSWORD.equals(item.getName())) {
  180.             type = SecurityConstants.SECRETKEYSTORE_TYPE;
  181.         }
  182.         else if(SecurityConstants.TRUSTSTORE_PASSWORD.equals(item.getName())) {
  183.             type = SecurityConstants.TRUSTSTORE_TYPE;
  184.             keystore = false;
  185.         }
  186.         
  187.         return processStorePassword(keystore, type, items, mapNameValue, item, actualValue);
  188.     }
  189.     private String dynamicUpdateStoreKeyPassword(List<?> items, Map<String, String> mapNameValue, Item item, String actualValue) {
  190.         if(!HSMUtils.isHsmConfigurableKeyPassword()) {
  191.             
  192.             String type = SecurityConstants.KEYSTORE_TYPE;
  193.             if(SecurityConstants.SECRETKEYSTORE_PRIVATE_KEY_PASSWORD.equals(item.getName())) {
  194.                 type = SecurityConstants.SECRETKEYSTORE_TYPE;
  195.             }
  196.             
  197.             return processStoreKeyPassword(type, items, mapNameValue, item, actualValue);
  198.         }
  199.         return actualValue;
  200.     }
  201.     private String dynamicUpdateByok(List<?> items, Map<String, String> mapNameValue, Item item, String actualValue) {      
  202.         if(!this.byokProvider.isByokEnabled()) {
  203.             item.setValue("");
  204.             item.setType(ItemType.HIDDEN);
  205.             return actualValue;
  206.         }
  207.         else {
  208.             return dynamicUpdateByokPolicy(items, mapNameValue, item, actualValue);
  209.         }
  210.     }
  211.     private String dynamicUpdateByokPolicy(List<?> items, Map<String, String> mapNameValue, Item item, String actualValue) {
  212.         String type = null;
  213.         if(SecurityConstants.SECRETKEYSTORE_BYOK_POLICY.equals(item.getName())) {
  214.             type = SecurityConstants.SECRETKEYSTORE_TYPE;
  215.         }
  216.         else if(SecurityConstants.KEYSTORE_BYOK_POLICY.equals(item.getName())) {
  217.             type = SecurityConstants.KEYSTORE_TYPE;
  218.         }
  219.         
  220.         return AbstractSecurityProvider.processStoreByokPolicy(type, items, mapNameValue, item, actualValue);
  221.     }
  222.     
  223.     public static String readValue(String identificativo, List<?> items, Map<String, String> mapNameValue) {
  224.         String value = null;
  225.         if(items!=null && !items.isEmpty()) {
  226.             for (Object itemCheck : items) {
  227.                 /**System.out.println("CHECK ["+itemCheck.getClass().getName()+"]");*/
  228.                 if(itemCheck instanceof Item) {
  229.                     Item listItem = (Item) itemCheck;
  230.                     
  231.                     if(identificativo.equals(listItem.getName())) {
  232.                         value = mapNameValue.get(identificativo);
  233.                         break;
  234.                     }
  235.                 }
  236.             }
  237.         }
  238.         return value;
  239.     }
  240.     
  241.     public static String processStoreFile(String type, List<?> items, Map<String, String> mapNameValue, Item item, String actualValue) {
  242.         if(items!=null && !items.isEmpty()) {
  243.             for (Object itemCheck : items) {
  244.                 /**System.out.println("CHECK ["+itemCheck.getClass().getName()+"]");*/
  245.                 if(itemCheck instanceof Item) {
  246.                     Item listItem = (Item) itemCheck;
  247.                     
  248.                     boolean find = false;
  249.                     String value = null;
  250.                     if(type.equals(listItem.getName())) {
  251.                         find = true;
  252.                         value = mapNameValue.get(type);
  253.                     }
  254.                                             
  255.                     if(find) {
  256.                         /**System.out.println("TROVATO TYPE ["+mapNameValue.get(SecurityConstants.KEYSTORE_TYPE)+"]");*/
  257.                         return processStoreFile(value, item, actualValue);
  258.                     }
  259.                 }
  260.             }
  261.         }
  262.         return actualValue;
  263.     }
  264.     private static String processStoreFile(String value, Item item, String actualValue) {
  265.         if(value!=null && HSMUtils.isKeystoreHSM(value)) {
  266.             /**System.out.println("SET HIDDEN ["+HSMUtils.KEYSTORE_HSM_PREFIX+value+"]");*/
  267.             item.setValue(HSMUtils.KEYSTORE_HSM_PREFIX+value);
  268.             item.setType(ItemType.HIDDEN);
  269.             return item.getValue();
  270.         }
  271.         else {
  272.             item.setValue(actualValue);
  273.             item.setType(ItemType.TEXTAREA);
  274.             return item.getValue();
  275.         }
  276.     }
  277.     
  278.     public static String processStorePassword(boolean keystore, String type, List<?> items, Map<String, String> mapNameValue, Item item, String actualValue) {
  279.         if(items!=null && !items.isEmpty()) {
  280.             for (Object itemCheck : items) {
  281.                 /**System.out.println("CHECK ["+itemCheck.getClass().getName()+"]");*/
  282.                 if(itemCheck instanceof Item) {
  283.                     Item listItem = (Item) itemCheck;
  284.                     boolean find = false;
  285.                     String value = null;
  286.                     if(type.equals(listItem.getName())) {
  287.                         find = true;
  288.                         value = mapNameValue.get(type);
  289.                     }
  290.                                             
  291.                     if(find) {
  292.                         /**System.out.println("TROVATO TYPE ["+mapNameValue.get(SecurityConstants.KEYSTORE_TYPE)+"]");*/
  293.                         processStorePasswordRequired(keystore, value, item);
  294.                         return processStorePassword(value, item, actualValue);
  295.                     }
  296.                 }
  297.             }
  298.         }
  299.         return actualValue;
  300.     }
  301.     private static String processStorePassword(String value, Item item, String actualValue) {
  302.         if(value!=null && HSMUtils.isKeystoreHSM(value)) {
  303.             /**System.out.println("SET HIDDEN ["+HSMUtils.KEYSTORE_HSM_PREFIX+value+"]");*/
  304.             item.setValue(HSMUtils.KEYSTORE_HSM_STORE_PASSWORD_UNDEFINED);
  305.             item.setType(ItemType.HIDDEN);
  306.             return item.getValue();
  307.         }
  308.         else {
  309.             item.setValue(actualValue);
  310.             item.setType(ItemType.LOCK);
  311.             return item.getValue();
  312.         }
  313.     }
  314.     private static void processStorePasswordRequired(boolean keystore, String value, Item item) {
  315.         if(KeystoreType.JKS.isType(value)) {
  316.             item.setRequired(keystore ? DBUtils.isKeystoreJksPasswordRequired() : DBUtils.isTruststoreJksPasswordRequired());
  317.         }
  318.         else if(KeystoreType.PKCS12.isType(value)) {
  319.             item.setRequired(keystore ? DBUtils.isKeystorePkcs12PasswordRequired() : DBUtils.isTruststorePkcs12PasswordRequired());
  320.         }
  321.     }
  322.     
  323.     public static String processStoreKeyPassword(String type, List<?> items, Map<String, String> mapNameValue, Item item, String actualValue) {
  324.         if(items!=null && !items.isEmpty()) {
  325.             for (Object itemCheck : items) {
  326.                 /**System.out.println("CHECK ["+itemCheck.getClass().getName()+"]");*/
  327.                 if(itemCheck instanceof Item) {
  328.                     Item listItem = (Item) itemCheck;
  329.                     boolean find = false;
  330.                     String value = null;
  331.                     if(type.equals(listItem.getName())) {
  332.                         find = true;
  333.                         value = mapNameValue.get(type);
  334.                     }
  335.                                             
  336.                     if(find) {
  337.                         /**System.out.println("TROVATO TYPE ["+mapNameValue.get(SecurityConstants.KEYSTORE_TYPE)+"]");*/
  338.                         processStoreKeyPasswordRequired(value, item);
  339.                         return processStoreKeyPassword(value, item, actualValue);
  340.                     }
  341.                 }
  342.             }
  343.         }
  344.         return actualValue;
  345.     }
  346.     private static String processStoreKeyPassword(String value, Item item, String actualValue) {
  347.         if(value!=null && HSMUtils.isKeystoreHSM(value)) {
  348.             /**System.out.println("SET HIDDEN ["+HSMUtils.KEYSTORE_HSM_PREFIX+value+"]");*/
  349.             item.setValue(HSMUtils.KEYSTORE_HSM_PRIVATE_KEY_PASSWORD_UNDEFINED);
  350.             item.setType(ItemType.HIDDEN);
  351.             return item.getValue();
  352.         }
  353.         else {
  354.             item.setValue(actualValue);
  355.             item.setType(ItemType.LOCK);
  356.             return item.getValue();
  357.         }
  358.     }
  359.     private static void processStoreKeyPasswordRequired(String value, Item item) {
  360.         if(KeystoreType.JKS.isType(value)) {
  361.             item.setRequired(DBUtils.isKeystoreJksKeyPasswordRequired());
  362.         }
  363.         else if(KeystoreType.PKCS12.isType(value)) {
  364.             item.setRequired(DBUtils.isKeystorePkcs12PasswordRequired());
  365.         }
  366.     }
  367.     
  368.     public static String processStoreByokPolicy(String type, List<?> items, Map<String, String> mapNameValue, Item item, String actualValue) {
  369.         if(items!=null && !items.isEmpty()) {
  370.             for (Object itemCheck : items) {
  371.                 /**System.out.println("CHECK ["+itemCheck.getClass().getName()+"]");*/
  372.                 if(itemCheck instanceof Item) {
  373.                     Item listItem = (Item) itemCheck;
  374.                     
  375.                     boolean find = false;
  376.                     String value = null;
  377.                     if(type.equals(listItem.getName())) {
  378.                         find = true;
  379.                         value = mapNameValue.get(type);
  380.                     }
  381.                                             
  382.                     if(find) {
  383.                         /**System.out.println("TROVATO TYPE ["+mapNameValue.get(SecurityConstants.KEYSTORE_TYPE)+"]");*/
  384.                         return processStoreByokPolicy(value, item, actualValue);
  385.                     }
  386.                 }
  387.             }
  388.         }
  389.         return actualValue;
  390.     }
  391.     private static String processStoreByokPolicy(String value, Item item, String actualValue) {
  392.         if(value!=null && HSMUtils.isKeystoreHSM(value)) {
  393.             /**System.out.println("SET HIDDEN ["+HSMUtils.KEYSTORE_HSM_PREFIX+value+"]");*/
  394.             item.setValue(BYOKProvider.BYOK_POLICY_UNDEFINED);
  395.             item.setType(ItemType.HIDDEN);
  396.             return item.getValue();
  397.         }
  398.         else {
  399.             item.setValue(actualValue);
  400.             item.setType(ItemType.SELECT);
  401.             return item.getValue();
  402.         }
  403.     }
  404. }
Created with JaCoCo 0.8.8.202204050719