MerlinProvider.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.security.keystore;

  23. import java.io.IOException;
  24. import java.security.KeyStore;
  25. import java.security.PrivateKey;
  26. import java.util.HashMap;
  27. import java.util.Properties;

  29. import org.apache.wss4j.common.crypto.PasswordEncryptor;
  30. import org.apache.wss4j.common.ext.WSSecurityException;
  31. import org.apache.wss4j.common.ext.WSSecurityException.ErrorCode;
  32. import org.openspcoop2.core.config.MessageSecurity;
  33. import org.openspcoop2.core.config.MessageSecurityFlow;
  34. import org.openspcoop2.core.config.MessageSecurityFlowParameter;
  35. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  36. import org.openspcoop2.security.keystore.cache.GestoreKeystoreCache;
  37. import org.openspcoop2.utils.certificate.KeystoreType;
  38. import org.openspcoop2.utils.certificate.byok.BYOKProvider;
  39. import org.openspcoop2.utils.certificate.byok.BYOKRequestParams;

  41. /**
  42.  * Implementazione che estente l'implementazione di default e permette di caricare keystore utilizzando la cache o il binario passato direttamente.
  43.  *
  44.  * @author Poli Andrea (apoli@link.it)
  45.  * @author $Author$
  46.  * @version $Rev$, $Date$
  47.  */
  48. public class MerlinProvider extends org.apache.wss4j.common.crypto.Merlin {

  50.     private static boolean useBouncyCastleProvider = false;
  51.     public static boolean isUseBouncyCastleProvider() {
  52.         return useBouncyCastleProvider;
  53.     }
  54.     public static void setUseBouncyCastleProvider(boolean useBouncyCastleProvider) {
  55.         MerlinProvider.useBouncyCastleProvider = useBouncyCastleProvider;
  56.     }
  57.     
  58.     public MerlinProvider() {
  59.         super();
  60.     }

  62.     public MerlinProvider(Properties properties, ClassLoader loader, PasswordEncryptor passwordEncryptor)
  63.             throws WSSecurityException, IOException {
  64.         super(properties, loader, passwordEncryptor);
  65.     }

  67.     private org.openspcoop2.utils.certificate.KeyStore op2KeyStore;
  68.     private org.openspcoop2.utils.certificate.KeyStore op2TrustStore;
  69.     public org.openspcoop2.utils.certificate.KeyStore getOp2KeyStore() {
  70.         return this.op2KeyStore;
  71.     }
  72.     public org.openspcoop2.utils.certificate.KeyStore getOp2TrustStore() {
  73.         return this.op2TrustStore;
  74.     }

  76.     private Boolean useBouncyCastleProviderDirective = null;
  77.     
  78.     public static String readPrefix(Properties properties) {
  79.         for (Object key : properties.keySet()) {
  80.             if (key instanceof String) {
  81.                 String propKey = (String)key;
  82.                 if (propKey.startsWith(PREFIX)) {
  83.                     return PREFIX;
  84.                 } else if (propKey.startsWith(OLD_PREFIX)) {
  85.                     return OLD_PREFIX;
  86.                 }
  87.             }
  88.         }
  89.         return PREFIX;
  90.     }
  91.     
  92.     private static final String TRUST_STORE_REF = "truststore";
  93.     private static final String KEY_STORE_REF = "keystore";
  94.     private String getError(String tipoStore, String location) {
  95.         if(location!=null) {
  96.             return "Accesso al "+tipoStore+" '"+location+"' non riuscito";
  97.         }
  98.         else {
  99.             return "Accesso al "+tipoStore+" non riuscito";
  100.         }
  101.     }
  102.     
  103.     public static final String SUFFIX_BYOK = ".byok";
  104.     
  105.     public static final String X509_CRL_FILE_VALIDATE_ONLY_END_ENTITY = X509_CRL_FILE + ".validateOnlyEndEntity";
  106.     
  107.     private static final String TRUE = "true";
  108.     private static final String FALSE = "false";
  109.     
  110.     @Override
  111.     public void loadProperties(Properties properties, ClassLoader loader, PasswordEncryptor passwordEncryptor)
  112.             throws WSSecurityException, IOException {

  114.         if (properties == null) {
  115.             return;
  116.         }
  117.         this.properties = properties;
  118.         this.passwordEncryptor = passwordEncryptor;

  120.         String prefix = readPrefix(properties);

  122.         
  123.         //
  124.         // Load the RequestInfo
  125.         //
  126.         RequestInfo requestInfo = null;
  127.         Object requestInfoObject = properties.get(KeystoreConstants.PROPERTY_REQUEST_INFO);
  128.         if(requestInfoObject instanceof RequestInfo) {
  129.             requestInfo = (RequestInfo) requestInfoObject;
  130.         }
  131.         

  133.         //
  134.         // Load the KeyStore
  135.         //
  136.         String keyStoreLocation = properties.getProperty(prefix + KEYSTORE_FILE);
  137.         if (keyStoreLocation == null) {
  138.             keyStoreLocation = properties.getProperty(prefix + OLD_KEYSTORE_FILE);
  139.         }
  140.         Object keyStoreArchiveObject = properties.get(prefix + KeystoreConstants.KEYSTORE);
  141.         byte [] keyStoreArchive = null;
  142.         if(keyStoreArchiveObject instanceof byte[]) {
  143.             keyStoreArchive = (byte[]) keyStoreArchiveObject;
  144.         }
  145.         
  146.         String keyStorePassword = properties.getProperty(prefix + KEYSTORE_PASSWORD);
  147.         if (keyStorePassword != null) {
  148.             keyStorePassword = keyStorePassword.trim();
  149.             keyStorePassword = decryptPassword(keyStorePassword, passwordEncryptor);
  150.         }
  151.         String keyStoreType = properties.getProperty(prefix + KEYSTORE_TYPE, KeyStore.getDefaultType());
  152.         if (keyStoreType != null) {
  153.             keyStoreType = keyStoreType.trim();
  154.         }
  155.                 
  156.         if (keyStoreLocation != null) {
  157.         
  158.             String keyStoreByokPolicy = properties.getProperty(prefix + KEYSTORE_FILE+SUFFIX_BYOK);
  159.             BYOKRequestParams byokParams = null;
  160.             if (keyStoreByokPolicy == null) {
  161.                 keyStoreByokPolicy = properties.getProperty(prefix + OLD_KEYSTORE_FILE+SUFFIX_BYOK);
  162.             }
  163.             if (keyStoreByokPolicy != null) {
  164.                 keyStoreByokPolicy = keyStoreByokPolicy.trim();
  165.                 if(BYOKProvider.isPolicyDefined(keyStoreByokPolicy)){
  166.                     try {
  167.                         byokParams = BYOKProvider.getBYOKRequestParamsByUnwrapBYOKPolicy(keyStoreByokPolicy, 
  168.                                 requestInfo!=null && requestInfo.getDynamicMap()!=null ? requestInfo.getDynamicMap() : new HashMap<>() );
  169.                     }catch(Exception e) {
  170.                         throw new IOException(e.getMessage(),e);
  171.                     }
  172.                 }
  173.             }
  174.             
  175.             // rimuovo la proprietà per non farla trovare quando chiamo il super.loadProperties
  176.             this.properties.remove(prefix + KEYSTORE_FILE);
  177.             this.properties.remove(prefix + OLD_KEYSTORE_FILE);
  178.         
  179.             // il set 'privatePasswordSet' e' stato riportato poichè eliminando sopra le due proprietà, questo codice non verra utilizzato nel super.loadProperties
  180.             String privatePasswd = properties.getProperty(prefix + KEYSTORE_PRIVATE_PASSWORD);
  181.             if (privatePasswd != null) {
  182.                 this.privatePasswordSet = true;
  183.             }
  184.             
  185.             
  186.             keyStoreLocation = keyStoreLocation.trim();

  188.             try {
  189.                 MerlinKeystore merlinKs = GestoreKeystoreCache.getMerlinKeystore(requestInfo, keyStoreLocation, keyStoreType, 
  190.                         keyStorePassword, byokParams);
  191.                 if(merlinKs==null) {
  192.                     throw new IOException(getError(KEY_STORE_REF,keyStoreLocation));
  193.                 }
  194.                 if(merlinKs.getKeyStore()==null) {
  195.                     throw new IOException(getError(KEY_STORE_REF,keyStoreLocation));
  196.                 }
  197.                 this.op2KeyStore = merlinKs.getKeyStore();
  198.                 this.keystore = this.op2KeyStore.getKeystore();
  199.             }catch(Exception e) {
  200.                 throw new IOException("[Keystore-File] '"+keyStoreLocation+"' "+e.getMessage(),e);
  201.             }

  203.         }
  204.         else if (keyStoreArchive != null) {
  205.             try {
  206.                 MerlinKeystore merlinKs = GestoreKeystoreCache.getMerlinKeystore(requestInfo, keyStoreArchive, keyStoreType, 
  207.                         keyStorePassword);
  208.                 if(merlinKs==null) {
  209.                     throw new IOException(getError(KEY_STORE_REF,null));
  210.                 }
  211.                 if(merlinKs.getKeyStore()==null) {
  212.                     throw new IOException(getError(KEY_STORE_REF,null));
  213.                 }
  214.                 this.op2KeyStore = merlinKs.getKeyStore();
  215.                 this.keystore = this.op2KeyStore.getKeystore();
  216.             }catch(Exception e) {
  217.                 throw new IOException("[Keystore-Archive] "+e.getMessage(),e);
  218.             }
  219.         }
  220.         

  222.         //
  223.         // Load the TrustStore
  224.         //
  225.         
  226.         String trustStoreLocation = properties.getProperty(prefix + TRUSTSTORE_FILE);
  227.         Object trustStoreArchiveObject = properties.get(prefix + KeystoreConstants.TRUSTSTORE);
  228.         byte [] trustStoreArchive = null;
  229.         if(trustStoreArchiveObject instanceof byte[]) {
  230.             trustStoreArchive = (byte[]) trustStoreArchiveObject;
  231.         }
  232.         
  233.         String trustStorePassword = properties.getProperty(prefix + TRUSTSTORE_PASSWORD);
  234.         if (trustStorePassword != null) {
  235.             trustStorePassword = trustStorePassword.trim();
  236.             trustStorePassword = decryptPassword(trustStorePassword, passwordEncryptor);
  237.         }
  238.         String trustStoreType = properties.getProperty(prefix + TRUSTSTORE_TYPE, KeyStore.getDefaultType());
  239.         if (trustStoreType != null) {
  240.             trustStoreType = trustStoreType.trim();
  241.         }
  242.         
  243.         if (trustStoreLocation != null) {
  244.             
  245.             // rimuovo la proprietà per non farla trovare quando chiamo il super.loadProperties
  246.             this.properties.remove(prefix + TRUSTSTORE_FILE);
  247.         
  248.             // il set 'loadCACerts' e' stato riportato poichè eliminando sopra le due proprietà, questo codice non verra utilizzato nel super.loadProperties
  249.             this.loadCACerts = false;
  250.             
  251.             trustStoreLocation = trustStoreLocation.trim();

  253.             try {
  254.                 MerlinTruststore merlinTs = GestoreKeystoreCache.getMerlinTruststore(requestInfo, trustStoreLocation, trustStoreType, 
  255.                         trustStorePassword);
  256.                 if(merlinTs==null) {
  257.                     throw new IOException(getError(TRUST_STORE_REF,trustStoreLocation));
  258.                 }
  259.                 if(merlinTs.getTrustStore()==null) {
  260.                     throw new IOException(getError(TRUST_STORE_REF,trustStoreLocation));
  261.                 }
  262.                 this.op2TrustStore = merlinTs.getTrustStore();
  263.                 this.truststore = this.op2TrustStore.getKeystore();
  264.             }catch(Exception e) {
  265.                 throw new IOException("[Truststore-File] '"+trustStoreLocation+"' "+e.getMessage(),e);
  266.             }

  268.         }
  269.         else if (trustStoreArchive != null) {
  270.             try {
  271.                 MerlinTruststore merlinTs = GestoreKeystoreCache.getMerlinTruststore(requestInfo, trustStoreArchive, trustStoreType, 
  272.                         trustStorePassword);
  273.                 if(merlinTs==null) {
  274.                     throw new IOException(getError(TRUST_STORE_REF,null));
  275.                 }
  276.                 if(merlinTs.getTrustStore()==null) {
  277.                     throw new IOException(getError(TRUST_STORE_REF,null));
  278.                 }
  279.                 this.op2TrustStore = merlinTs.getTrustStore();
  280.                 this.truststore = this.op2TrustStore.getKeystore();
  281.             }catch(Exception e) {
  282.                 throw new IOException("[Truststore-Archive] "+e.getMessage(),e);
  283.             }
  284.         }
  285.         
  286.         if(this.truststore!=null) {
  287.             
  288.             // Devo evitare che venga eseguito il loadCerts quando invoco super.loadProperties
  289.             
  290.             properties.remove(prefix + LOAD_CA_CERTS);
  291.             properties.setProperty(prefix + LOAD_CA_CERTS, FALSE);
  292.             
  293.         }
  294.         


  297.         //
  298.         // Load the CRL file(s)
  299.         //
  300.         String crlLocations = properties.getProperty(prefix + X509_CRL_FILE);
  301.         if (crlLocations != null) {
  302.             
  303.             // rimuovo la proprietà per non farla trovare quando chiamo il super.loadProperties
  304.             this.properties.remove(prefix + X509_CRL_FILE);
  305.             
  306.             CRLCertstore crlCertstore = null;
  307.             try {
  308.                 crlCertstore = GestoreKeystoreCache.getCRLCertstore(requestInfo, crlLocations);
  309.                 if(crlCertstore==null) {
  310.                     throw new IOException("Accesso alle crl '"+crlLocations+"' non riuscito");
  311.                 }
  312.                 this.crlCertStore = crlCertstore.getCertStore();
  313.             }catch(Exception e) {
  314.                 throw new IOException("[CRLCertstore] "+e.getMessage(),e);
  315.             }

  317.             String useBouncyCastleProviderProperty = properties.getProperty(prefix + "useBouncyCastleProvider");
  318.             if (useBouncyCastleProviderProperty != null) {
  319.                 if(TRUE.equalsIgnoreCase(useBouncyCastleProviderProperty.trim())) {
  320.                     this.useBouncyCastleProviderDirective = true;
  321.                 }
  322.                 else if(FALSE.equalsIgnoreCase(useBouncyCastleProviderProperty.trim())) {
  323.                     this.useBouncyCastleProviderDirective = false;
  324.                 }
  325.             }
  326.             
  327.             String validateOnlyEndEntity = properties.getProperty(prefix + X509_CRL_FILE_VALIDATE_ONLY_END_ENTITY);
  328.             if (validateOnlyEndEntity != null) {
  329.                 if(TRUE.equalsIgnoreCase(validateOnlyEndEntity.trim())) {
  330.                     this.setValidateOnlyEndEntity(true);
  331.                 }
  332.                 else if(FALSE.equalsIgnoreCase(validateOnlyEndEntity.trim())) {
  333.                     this.setValidateOnlyEndEntity(false);
  334.                 }
  335.             }
  336.             else if(crlCertstore!=null && crlCertstore.getWrappedCRLCertStore()!=null && crlCertstore.getWrappedCRLCertStore().countCrls()==1) {
  337.                 // per default si assume che venga fornito solo il file CRL del certificato finale
  338.                 this.setValidateOnlyEndEntity(true);
  339.             }
  340.             
  341.         }



  345.         //
  346.         // Super
  347.         //
  348.         super.loadProperties(properties, loader, passwordEncryptor);
  349.     }

  351.     /**@Override
  352.     public PrivateKey getPrivateKey(PublicKey publicKey, CallbackHandler callbackHandler) throws WSSecurityException {
  353.         System.out.println("@@@ getPrivateKey PUBLIC KEY, CALLBACK");
  354.         return super.getPrivateKey(publicKey, callbackHandler);
  355.     }*/

  357.     @Override
  358.     public PrivateKey getPrivateKey(String alias, String password) throws WSSecurityException {
  359.         /**System.out.println("@@@ getPrivateKey arg0["+alias+"] arg1["+password+"]");*/
  360.         if(this.op2KeyStore!=null) {
  361.             try {
  362.                 return this.op2KeyStore.getPrivateKey(alias, password);
  363.             }catch(Exception e) {
  364.                 throw new WSSecurityException(ErrorCode.SECURITY_ERROR,e);
  365.             }
  366.         }
  367.         return super.getPrivateKey(alias, password);
  368.     }

  370.     /**@Override
  371.     public PrivateKey getPrivateKey(X509Certificate x509, CallbackHandler callbackHandler) throws WSSecurityException {
  372.         System.out.println("@@@ getPrivateKey X509Certificatw, CALLBACK");
  373.         return super.getPrivateKey(x509, callbackHandler);
  374.     }*/
  375.     
  376.     @Override
  377.     public String getCryptoProvider() {
  378.         boolean useBC = (this.useBouncyCastleProviderDirective!=null && this.useBouncyCastleProviderDirective) 
  379.                 ||
  380.                 (MerlinProvider.useBouncyCastleProvider);
  381.         if(useBC) {
  382.             if(this.truststore!=null && this.truststore.getType()!=null && this.truststore.getType().equalsIgnoreCase(KeystoreType.PKCS11.getNome())) {
  383.                 useBC=false;
  384.             }
  385.             if(this.keystore!=null && this.keystore.getType()!=null && this.keystore.getType().equalsIgnoreCase(KeystoreType.PKCS11.getNome())) {
  386.                 useBC=false;
  387.             }
  388.         }
  389.         if(useBC) {
  390.             return org.bouncycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME;
  391.         }
  392.         else {
  393.             return super.getCryptoProvider();
  394.         }
  395.     }
  396.     
  397.     public static void correctProviderName(MessageSecurity messageSecurity){
  398.         if(messageSecurity!=null) {
  399.             MessageSecurityFlow request = messageSecurity.getRequestFlow();
  400.             correctProviderNameRequestFlow(request);
  401.             
  402.             MessageSecurityFlow response = messageSecurity.getResponseFlow();
  403.             correctProviderNameResponseFlow(response);
  404.         }
  405.     }
  406.     private static void correctProviderNameRequestFlow(MessageSecurityFlow request){
  407.         if(request!=null && request.sizeParameterList()>0) {
  408.             for (MessageSecurityFlowParameter param : request.getParameterList()) {
  409.                 if(param.getNome()!=null && param.getNome().trim().endsWith(KeystoreConstants.PROPERTY_PROVIDER) && 
  410.                         param.getValore()!=null && KeystoreConstants.OLD_PROVIDER_GOVWAY.equals(param.getValore().trim()) ) {
  411.                     param.setValore(KeystoreConstants.PROVIDER_GOVWAY);
  412.                 }
  413.             }
  414.         }
  415.     }
  416.     private static void correctProviderNameResponseFlow(MessageSecurityFlow response){
  417.         if(response!=null && response.sizeParameterList()>0) {
  418.             for (MessageSecurityFlowParameter param : response.getParameterList()) {
  419.                 if(param.getNome()!=null && param.getNome().trim().endsWith(KeystoreConstants.PROPERTY_PROVIDER) && 
  420.                         param.getValore()!=null && KeystoreConstants.OLD_PROVIDER_GOVWAY.equals(param.getValore().trim()) ) {
  421.                     param.setValore(KeystoreConstants.PROVIDER_GOVWAY);
  422.                 }
  423.             }
  424.         }
  425.     }
  426. }
Created with JaCoCo 0.8.8.202204050719