JsonUtils.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.utils.security;

  23. import java.io.File;
  24. import java.io.InputStream;
  25. import java.net.URI;
  26. import java.nio.file.Files;
  27. import java.security.Key;
  28. import java.security.PrivateKey;
  29. import java.security.cert.CertStore;
  30. import java.security.cert.Certificate;
  31. import java.security.cert.CertificateExpiredException;
  32. import java.security.cert.CertificateNotYetValidException;
  33. import java.util.Properties;

  35. import javax.crypto.SecretKey;

  37. import org.apache.commons.lang.StringUtils;
  38. import org.apache.cxf.message.Exchange;
  39. import org.apache.cxf.message.ExchangeImpl;
  40. import org.apache.cxf.message.Message;
  41. import org.apache.cxf.message.MessageImpl;
  42. import org.apache.cxf.phase.PhaseInterceptorChain;
  43. import org.apache.cxf.rs.security.jose.common.JoseConstants;
  44. import org.apache.cxf.rs.security.jose.common.KeyManagementUtils;
  45. import org.apache.cxf.rs.security.jose.jwa.ContentAlgorithm;
  46. import org.apache.cxf.rs.security.jose.jwe.ContentEncryptionProvider;
  47. import org.apache.cxf.rs.security.jose.jwe.JweDecryptionProvider;
  48. import org.apache.cxf.rs.security.jose.jwe.JweEncryption;
  49. import org.apache.cxf.rs.security.jose.jwe.JweEncryptionProvider;
  50. import org.apache.cxf.rs.security.jose.jwe.JweException;
  51. import org.apache.cxf.rs.security.jose.jwe.JweHeaders;
  52. import org.apache.cxf.rs.security.jose.jwe.JweUtils;
  53. import org.apache.cxf.rs.security.jose.jwe.KeyEncryptionProvider;
  54. import org.apache.cxf.rs.security.jose.jwe.WrappedKeyDecryptionAlgorithm;
  55. import org.apache.cxf.rs.security.jose.jwk.JsonWebKey;
  56. import org.apache.cxf.rs.security.jose.jwk.JsonWebKeys;
  57. import org.apache.cxf.rs.security.jose.jwk.JwkUtils;
  58. import org.apache.cxf.rs.security.jose.jwk.KeyOperation;
  59. import org.apache.cxf.rs.security.jose.jws.JwsException;
  60. import org.apache.cxf.rs.security.jose.jws.JwsSignatureProvider;
  61. import org.apache.cxf.rs.security.jose.jws.JwsSignatureVerifier;
  62. import org.apache.cxf.rs.security.jose.jws.JwsUtils;
  63. import org.apache.cxf.rs.security.jose.jws.PrivateKeyJwsSignatureProvider;
  64. import org.apache.cxf.rt.security.rs.RSSecurityConstants;
  65. import org.openspcoop2.utils.Utilities;
  66. import org.openspcoop2.utils.UtilsException;
  67. import org.openspcoop2.utils.certificate.CertificateInfo;
  68. import org.openspcoop2.utils.certificate.KeyStore;
  69. import org.openspcoop2.utils.certificate.KeystoreType;
  70. import org.openspcoop2.utils.io.Base64Utilities;
  71. import org.openspcoop2.utils.json.JSONUtils;
  72. import org.openspcoop2.utils.resources.FileSystemUtilities;
  73. import org.openspcoop2.utils.transport.http.HttpResponse;
  74. import org.openspcoop2.utils.transport.http.HttpUtilities;
  75. import org.openspcoop2.utils.transport.http.IOCSPValidator;

  77. import com.fasterxml.jackson.databind.JsonNode;

  79. /**
  80.  * JsonUtils
  81.  * 
  82.  * @author Bussu Giovanni (bussu@link.it)
  83.  * @author  $Author$
  84.  * @version $Rev$, $Date$
  85.  * 
  86.  */
  87. public class JsonUtils {
  88.     
  89.     private JsonUtils(){}

  91.     public static Message newMessage() {
  92.         Message m = new MessageImpl();
  93.         Exchange ex = new ExchangeImpl();
  94.         m.setExchange(ex);
  95.         return m;
  96.     }
  97.     
  98.     private static final String KEYSTORE_PREFIX_FILE = "keystore";
  99.     
  100.     private static final String JCEKS_SIGNATURE_ALGO_UNDEFINED = "(JCEKS) Signature Algorithm undefined";
  101.     private static final String PKCS11_SIGNATURE_ALGO_UNDEFINED = "(SecretKey PKCS11) Signature Algorithm undefined";
  102.     private static final String SECRET_SIGNATURE_ALGO_UNDEFINED = "(Secret) Signature Algorithm undefined";
  103.     
  104.     private static final String JCEKS_CONTENT_ALGO_UNDEFINED = "(JCEKS) Content Algorithm undefined";
  105.     
  106.     public static final boolean SIGNATURE = true;
  107.     public static final boolean ENCRYPT = false;
  108.     public static final boolean DECRYPT = false;
  109.     public static final boolean SENDER = true;
  110.     public static final boolean RECEIVER = false;
  111.     public static UtilsException convert(JOSESerialization serialization, boolean signature, boolean roleSender, Throwable t) {
  112.         
  113.         StringBuilder bf = new StringBuilder();
  114.         if(serialization!=null) {
  115.             bf.append("[").append(serialization.name()).append("] ");
  116.         }
  117.         
  118.         if(t instanceof JwsException) {
  119.             JwsException exc = (JwsException) t;
  120.             if(exc.getError()==null) {
  121.                 if(roleSender) {
  122.                     bf.append("Signature failure");
  123.                 }
  124.                 else {
  125.                     bf.append("Signature verification failure");
  126.                 }
  127.             }           
  128.             else {
  129.                 bf.append(exc.getError().name());
  130.             }
  131.             if(exc.getMessage()==null && exc.getCause()==null && exc.getLocalizedMessage()==null) {
  132.                 return new UtilsException(bf.toString(),t);
  133.             }
  134.         }
  135.         else if(t instanceof JweException) {
  136.             JweException exc = (JweException) t;
  137.             if(exc.getError()==null) {
  138.                 if(roleSender) {
  139.                     bf.append("Encrypt failure");
  140.                 }
  141.                 else {
  142.                     bf.append("Decrypt failure");
  143.                 }
  144.             }           
  145.             else {
  146.                 bf.append(exc.getError().name());
  147.             }
  148.             if(exc.getMessage()==null && exc.getCause()==null && exc.getLocalizedMessage()==null) {
  149.                 return new UtilsException(bf.toString(),t);
  150.             }
  151.         }
  152.         else if(signature) {
  153.             if(roleSender) {
  154.                 bf.append("Signature failure");
  155.             }
  156.             else {
  157.                 bf.append("Signature verification failure");
  158.             }
  159.         }
  160.         else {
  161.             if(roleSender) {
  162.                 bf.append("Encrypt failure");
  163.             }
  164.             else {
  165.                 bf.append("Decrypt failure");
  166.             }
  167.         }
  168.                 
  169.         String msg = Utilities.getInnerNotEmptyMessageException(t).getMessage();
  170.         
  171.         Throwable innerExc = Utilities.getLastInnerException(t);
  172.         String innerMsg = null;
  173.         if(innerExc!=null){
  174.             innerMsg = innerExc.getMessage();
  175.         }
  176.         
  177.         String messaggio = null;
  178.         if(msg!=null && !"".equals(msg) && !"null".equals(msg)) {
  179.             messaggio = msg+"";
  180.             if(innerMsg!=null && !"".equals(innerMsg) && !"null".equals(innerMsg) && !innerMsg.equals(msg) &&
  181.                 !messaggio.contains(innerMsg)) {
  182.                 messaggio = messaggio + " ; " + innerMsg;
  183.             }
  184.         }
  185.         else{
  186.             if(innerMsg!=null && !"".equals(innerMsg) && !"null".equals(innerMsg)) {
  187.                 messaggio = innerMsg;
  188.             }
  189.         }
  190.         
  191.         if(messaggio!=null) {
  192.             bf.append(": ");
  193.             bf.append(messaggio);
  194.         }
  195.         return new UtilsException(bf.toString(),t);
  196.     }
  197.     
  198.     public static byte[] readKeystoreFromURI(Properties props) throws UtilsException {
  199.         
  200.         String propertyKeystoreName = RSSecurityConstants.RSSEC_KEY_STORE_FILE;
  201.         String path = props.getProperty(propertyKeystoreName);
  202.         byte[]content = null;
  203.         if(path!=null && (path.startsWith("http") || path.startsWith("https"))) {
  204.             HttpResponse httpResponse = null;
  205.             String trustStoreProperty =  RSSecurityConstants.RSSEC_KEY_STORE_FILE+".ssl";
  206.             String trustStorePasswordProperty =  RSSecurityConstants.RSSEC_KEY_STORE_PSWD+".ssl";
  207.             String trustStoreTypeProperty =  RSSecurityConstants.RSSEC_KEY_STORE_TYPE+".ssl";
  208.             String trustStore = props.getProperty(trustStoreProperty);
  209.             String trustStorePassword = props.getProperty(trustStorePasswordProperty);
  210.             String trustStoreType = props.getProperty(trustStoreTypeProperty);
  211.             if(trustStore!=null) {
  212.                 if(trustStorePassword==null) {
  213.                     throw new UtilsException("TrustStore ssl password undefined");
  214.                 }
  215.                 if(trustStoreType==null) {
  216.                     throw new UtilsException("TrustStore ssl type undefined");
  217.                 }
  218.             }
  219.             if( (path.startsWith("https:") && trustStore==null) || path.startsWith("http:") ) {
  220.                 /**System.out.println("http");*/
  221.                 httpResponse = HttpUtilities.getHTTPResponse(path, 60000, 10000);
  222.             }
  223.             else {
  224.                 /**System.out.println("https");*/
  225.                 httpResponse = HttpUtilities.getHTTPSResponse(path, 60000, 10000, trustStore, trustStorePassword, trustStoreType);
  226.             }
  227.             if(httpResponse==null || httpResponse.getContent()==null) {
  228.                 throw new UtilsException("Keystore '"+path+"' unavailable");
  229.             }
  230.             if(httpResponse.getResultHTTPOperation()!=200) {
  231.                 throw new UtilsException("Retrieve keystore '"+path+"' failed (returnCode:"+httpResponse.getResultHTTPOperation()+")");
  232.             }
  233.             content = httpResponse.getContent();
  234.         }
  235.         else if(path!=null && (path.startsWith("file"))){
  236.             try {
  237.                 File f = new File(new URI(path));
  238.                 content = FileSystemUtilities.readBytesFromFile(f);
  239.             }catch(Exception e) {
  240.                 throw new UtilsException(e.getMessage(),e);
  241.             }
  242.         }
  243.         
  244.         return content;
  245.     }
  246.     
  247.     public static File normalizeProperties(Properties props) throws UtilsException {
  248.         
  249.         String propertyKeystoreName = RSSecurityConstants.RSSEC_KEY_STORE_FILE;
  250.         byte[] content = readKeystoreFromURI(props);
  251.         
  252.         File fTmp = null;
  253.         if(content!=null) {
  254.         
  255.             String tipo = props.getProperty(RSSecurityConstants.RSSEC_KEY_STORE_TYPE);
  256.             if(tipo==null) {
  257.                 tipo = KeystoreType.JKS.getNome();
  258.             }
  259.             
  260.             try {
  261.                 fTmp = FileSystemUtilities.createTempFile(KEYSTORE_PREFIX_FILE, "."+tipo);
  262.             }catch(Exception e) {
  263.                 throw new UtilsException(e.getMessage(),e);
  264.             }
  265.             FileSystemUtilities.writeFile(fTmp, content);
  266.             props.remove(propertyKeystoreName);
  267.             props.put(propertyKeystoreName, fTmp.getAbsolutePath());
  268.             
  269.         }
  270.         
  271.         return fTmp;
  272.     }
  273.     
  274.     public static boolean isDynamicProvider(Properties props) {
  275.         String alias = props.getProperty(RSSecurityConstants.RSSEC_KEY_STORE_ALIAS);
  276.         if("*".equalsIgnoreCase(alias)) {
  277.             props.remove(RSSecurityConstants.RSSEC_KEY_STORE_ALIAS);
  278.             return true;
  279.         }
  280.         return false;
  281.     }
  282.     
  283.     public static String readAlias(String jsonString) throws UtilsException {
  284.         if(!jsonString.contains(".")) {
  285.             throw new UtilsException("Invalid format (expected COMPACT)");
  286.         }
  287.         String [] tmp = jsonString.split("\\.");
  288.         byte[] header = Base64Utilities.decode(tmp[0].trim());
  289.         JsonNode node = JSONUtils.getInstance().getAsNode(header).get("kid");
  290.         if(node==null) {
  291.             throw new UtilsException("Claim 'kid' not found");
  292.         }
  293.         String kid = node.asText();
  294.         if(kid==null) {
  295.             throw new UtilsException("Claim 'kid' without value");
  296.         }
  297.         return kid;
  298.     }

  300.     public static JsonWebKey readKey(JsonWebKeys jsonWebKeys, String alias) throws UtilsException {
  301.         if(alias==null) {
  302.             throw new UtilsException("Alias unknonw");
  303.         }
  304.         JsonWebKey jsonWebKey = jsonWebKeys.getKey(alias);
  305.         if(jsonWebKey==null) {
  306.             throw new UtilsException("Key with alias '"+alias+"' unknonw");
  307.         }
  308.         return jsonWebKey;
  309.     }
  310.     
  311.     public static KeyStore getKeyStore(Properties props) throws UtilsException {
  312.         return getKeyStore(true, true, props);
  313.     }
  314.     public static KeyStore getKeyStore(boolean jksPasswordRequired, boolean pkcs12PasswordRequired, Properties props) throws UtilsException {
  315.         Object oKeystore = props.get(RSSecurityConstants.RSSEC_KEY_STORE);
  316.         if(oKeystore instanceof KeyStore) {
  317.             return (KeyStore) oKeystore;
  318.         }
  319.         else if(oKeystore instanceof java.security.KeyStore) {
  320.             return new KeyStore((java.security.KeyStore) oKeystore);
  321.         }
  322.         else {
  323.             String fileK = props.getProperty(RSSecurityConstants.RSSEC_KEY_STORE_FILE);
  324.             if(fileK!=null) {
  325.                 String password = props.getProperty(RSSecurityConstants.RSSEC_KEY_STORE_PSWD);
  326.                 String type = props.getProperty(RSSecurityConstants.RSSEC_KEY_STORE_TYPE);
  327.                 
  328.                 if(password==null || "".equals(password)){
  329.                     boolean required = true;
  330.                     if(KeystoreType.JKS.isType(type)) {
  331.                         required = jksPasswordRequired;
  332.                     }
  333.                     else if(KeystoreType.PKCS12.isType(type)) {
  334.                         required = pkcs12PasswordRequired;
  335.                     }
  336.                     if(required) {
  337.                         throw new UtilsException("Keystore password undefined");
  338.                     }
  339.                 }
  340.                 if(type==null || "".equals(type)){
  341.                     type = KeystoreType.JKS.getNome();
  342.                 }
  343.                 if(KeystoreType.JWK_SET.getNome().equalsIgnoreCase(type)
  344.                     ||
  345.                     KeystoreType.PUBLIC_KEY.getNome().equalsIgnoreCase(type)
  346.                     ||
  347.                     KeystoreType.KEY_PAIR.getNome().equalsIgnoreCase(type)) {
  348.                     return null;
  349.                 }
  350.                 
  351.                 File file = new File(fileK);
  352.                 if(file.exists()) {
  353.                     return new KeyStore(file.getAbsolutePath(), type, password);
  354.                 }
  355.                 else {
  356.                     InputStream is = JsonUtils.class.getResourceAsStream(fileK);
  357.                     File fTmp = null;
  358.                     try {
  359.                         if(is!=null) {
  360.                             byte[] f = Utilities.getAsByteArray(is);
  361.                             try {
  362.                                 fTmp = FileSystemUtilities.createTempFile(KEYSTORE_PREFIX_FILE, ".tmp");
  363.                                 FileSystemUtilities.writeFile(fTmp, f);
  364.                                 return new KeyStore(fTmp.getAbsolutePath(), type, password);
  365.                             }catch(Exception e) {
  366.                                 throw new UtilsException(e.getMessage(),e);
  367.                             }
  368.                         }
  369.                     }finally {
  370.                         try {
  371.                             if(is!=null) {
  372.                                 is.close();
  373.                             }
  374.                         }catch(Exception e) {
  375.                             // ignore
  376.                         }
  377.                         try {
  378.                             if(fTmp!=null) {
  379.                                 Files.delete(fTmp.toPath());
  380.                             }
  381.                         }catch(Exception e) {
  382.                             // delete
  383.                         }
  384.                     }
  385.                 }   
  386.             }
  387.         }
  388.         return null;
  389.     }
  390.     public static Certificate getCertificateKey(Properties props) throws UtilsException {
  391.         return getCertificateKey(true, true, props);
  392.     }
  393.     public static Certificate getCertificateKey(boolean jksPasswordRequired, boolean pkcs12PasswordRequired, Properties props) throws UtilsException {
  394.         KeyStore keystore = getKeyStore(jksPasswordRequired, pkcs12PasswordRequired, props);
  395.         if(keystore!=null) {
  396.             String alias = props.getProperty(RSSecurityConstants.RSSEC_KEY_STORE_ALIAS);
  397.             if(alias!=null && !"".equals(alias)){
  398.                 return keystore.getCertificate(alias);
  399.             }
  400.         }
  401.         return null;
  402.     }
  403.     
  404.     public static SecretKeyPkcs11 getSecretKeyPKCS11(Properties props) throws UtilsException {
  405.         if(props.containsKey(RSSecurityConstants.RSSEC_KEY_STORE_TYPE)) {
  406.             String type = props.getProperty(RSSecurityConstants.RSSEC_KEY_STORE_TYPE);
  407.             
  408.             if(KeystoreType.PKCS11.getNome().equalsIgnoreCase(type)) {
  409.                 Object oKeystore = props.get(RSSecurityConstants.RSSEC_KEY_STORE);
  410.                 if(oKeystore instanceof java.security.KeyStore) {
  411.                     java.security.KeyStore keystorePKCS11 = (java.security.KeyStore) oKeystore;
  412.                     String alias = props.getProperty(RSSecurityConstants.RSSEC_KEY_STORE_ALIAS);
  413.                     if(alias==null || "".equals(alias)){
  414.                         throw new UtilsException("(Secret-PKCS11) Alias key undefined");
  415.                     }               
  416.                     Key key = null;
  417.                     try {
  418.                         key = keystorePKCS11.getKey(alias, null);
  419.                     }catch(Exception e) {
  420.                         throw new UtilsException(e.getMessage(),e);
  421.                     }
  422.                     if(key instanceof SecretKey) {
  423.                         return new SecretKeyPkcs11(keystorePKCS11.getProvider(), (SecretKey) key);
  424.                     }
  425.                 }
  426.             }
  427.         }
  428.         return null;
  429.     }
  430.     public static SecretKey getSecretKey(Properties props) throws UtilsException {
  431.         if(props.containsKey(RSSecurityConstants.RSSEC_KEY_STORE_TYPE)) {
  432.             String type = props.getProperty(RSSecurityConstants.RSSEC_KEY_STORE_TYPE);
  433.             
  434.             if(KeystoreType.JCEKS.getNome().equalsIgnoreCase(type)) {
  435.                 Object oKeystore = props.get(RSSecurityConstants.RSSEC_KEY_STORE);
  436.                 String fileK = props.getProperty(RSSecurityConstants.RSSEC_KEY_STORE_FILE);
  437.                 String password = props.getProperty(RSSecurityConstants.RSSEC_KEY_STORE_PSWD);
  438.                 String alias = props.getProperty(RSSecurityConstants.RSSEC_KEY_STORE_ALIAS);
  439.                 String passwordKey = props.getProperty(RSSecurityConstants.RSSEC_KEY_PSWD);
  440.                 
  441.                 if(oKeystore instanceof java.security.KeyStore) {
  442.                     java.security.KeyStore keystoreJCEKS = (java.security.KeyStore) oKeystore;
  443.                     
  444.                     if(alias==null || "".equals(alias)){
  445.                         throw new UtilsException("(JCEKS) Alias key undefined");
  446.                     }
  447.                     if(passwordKey==null || "".equals(passwordKey)){
  448.                         throw new UtilsException("(JCEKS) Password key undefined");
  449.                     }
  450.                     
  451.                     try {
  452.                         return (SecretKey) keystoreJCEKS.getKey(alias, passwordKey.toCharArray());
  453.                     }catch(Exception e) {
  454.                         throw new UtilsException(e.getMessage(),e);
  455.                     }
  456.                 }
  457.                 else if(fileK!=null) {
  458.                     
  459.                     if(password==null || "".equals(password)){
  460.                         throw new UtilsException("(JCEKS) Keystore password undefined");
  461.                     }
  462.                     
  463.                     File file = new File(fileK);
  464.                     KeyStore keystoreJCEKS = null;
  465.                     if(file.exists()) {
  466.                         keystoreJCEKS = new KeyStore(file.getAbsolutePath(), KeystoreType.JCEKS.getNome(), password);
  467.                     }
  468.                     else {
  469.                         InputStream is = JsonUtils.class.getResourceAsStream(fileK);
  470.                         File fTmp = null;
  471.                         try {
  472.                             if(is!=null) {
  473.                                 byte[] f = Utilities.getAsByteArray(is);
  474.                                 try {
  475.                                     fTmp = FileSystemUtilities.createTempFile(KEYSTORE_PREFIX_FILE, ".jceks");
  476.                                     FileSystemUtilities.writeFile(fTmp, f);
  477.                                 }catch(Exception e) {
  478.                                     throw new UtilsException(e.getMessage(),e);
  479.                                 }
  480.                                 keystoreJCEKS = new KeyStore(fTmp.getAbsolutePath(), KeystoreType.JCEKS.getNome(), password);
  481.                             }
  482.                         }finally {
  483.                             try {
  484.                                 if(is!=null) {
  485.                                     is.close();
  486.                                 }
  487.                             }catch(Exception e) {
  488.                                 // ignore
  489.                             }
  490.                             try {
  491.                                 if(fTmp!=null) {
  492.                                     java.nio.file.Files.delete(fTmp.toPath());
  493.                                 }
  494.                             }catch(Exception e) {
  495.                                 // delete
  496.                             }
  497.                         }
  498.                     }   
  499.                     if(keystoreJCEKS!=null) {
  500.                         
  501.                         if(alias==null || "".equals(alias)){
  502.                             throw new UtilsException("(JCEKS) Alias key undefined");
  503.                         }
  504.                         if(passwordKey==null || "".equals(passwordKey)){
  505.                             throw new UtilsException("(JCEKS) Password key undefined");
  506.                         }
  507.                         
  508.                         return keystoreJCEKS.getSecretKey(alias, passwordKey);
  509.                     }

  511.                 }
  512.             }
  513.         }
  514.         return null;
  515.     }
  516.     public static final String RSSEC_KEY_STORE_TYPE_SECRET = "secret";
  517.     public static String getSecret(Properties props, org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm algorithm) {
  518.         if(props.containsKey(RSSecurityConstants.RSSEC_KEY_STORE_TYPE)) {
  519.             String type = props.getProperty(RSSecurityConstants.RSSEC_KEY_STORE_TYPE);
  520.             if(RSSEC_KEY_STORE_TYPE_SECRET.equalsIgnoreCase(type)) { // customized
  521.                 if(algorithm!=null) {
  522.                     if(algorithm.name().toLowerCase().startsWith("hs")) {
  523.                         String passwordKey = props.getProperty(RSSecurityConstants.RSSEC_KEY_PSWD);
  524.                         if(passwordKey!=null && StringUtils.isNotEmpty(passwordKey)) {
  525.                             return passwordKey;
  526.                         }
  527.                     }
  528.                 }
  529.                 else {
  530.                     if(props.containsKey(RSSecurityConstants.RSSEC_SIGNATURE_ALGORITHM)) {
  531.                         
  532.                         String algo = props.getProperty(RSSecurityConstants.RSSEC_SIGNATURE_ALGORITHM);
  533.                         if(algo!=null && algo.toLowerCase().startsWith("hs")) {
  534.                             String passwordKey = props.getProperty(RSSecurityConstants.RSSEC_KEY_PSWD);
  535.                             if(passwordKey!=null && StringUtils.isNotEmpty(passwordKey)) {
  536.                                 return passwordKey;
  537.                             }
  538.                         }
  539.                         
  540.                     }           
  541.                 }
  542.             }
  543.         }
  544.         return null;
  545.     }
  546.         
  547.     public static JwsSignatureProvider getJwsSymmetricProvider(Properties props) throws UtilsException {
  548.         String algorithm = props.getProperty(RSSecurityConstants.RSSEC_SIGNATURE_ALGORITHM);
  549.         return getJwsSymmetricProvider(props, algorithm);
  550.     }
  551.     public static JwsSignatureProvider getJwsSymmetricProvider(Properties props, String algorithm) throws UtilsException {
  552.         org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm algo = null;
  553.         if(algorithm==null || "".equals(algorithm)) {
  554.             String type = props.getProperty(RSSecurityConstants.RSSEC_KEY_STORE_TYPE);
  555.             if(KeystoreType.JCEKS.getNome().equalsIgnoreCase(type)) {
  556.                 throw new UtilsException(JCEKS_SIGNATURE_ALGO_UNDEFINED);   
  557.             }
  558.         }
  559.         else{
  560.             algo = org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm.getAlgorithm(algorithm);
  561.         }
  562.         return getJwsSymmetricProvider(props, algo);
  563.     }
  564.     public static JwsSignatureProvider getJwsSymmetricProvider(Properties props, org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm algorithm) throws UtilsException {
  565.         
  566.         SecretKeyPkcs11 secretKeyPkcs11 = getSecretKeyPKCS11(props);
  567.         if(secretKeyPkcs11!=null) {
  568.             if(algorithm==null) {
  569.                 throw new UtilsException(PKCS11_SIGNATURE_ALGO_UNDEFINED);
  570.             }
  571.             return new HmacJwsSignatureProviderExtended(secretKeyPkcs11, algorithm);
  572.         }
  573.         
  574.         SecretKey secretKey = getSecretKey(props);
  575.         if(secretKey!=null) {
  576.             if(algorithm==null) {
  577.                 throw new UtilsException(JCEKS_SIGNATURE_ALGO_UNDEFINED);
  578.             }
  579.             byte[] encoded = secretKey.getEncoded();
  580.             JwsSignatureProvider provider = JwsUtils.getHmacSignatureProvider(encoded, algorithm);
  581.             if(provider==null) {
  582.                 throw new UtilsException("(JCEKS) JwsSignatureProvider init failed; check signature algorithm ("+algorithm+")");
  583.             }
  584.             return provider;
  585.         }
  586.         else {
  587.             String secret = getSecret(props, algorithm);
  588.             if(secret!=null) {
  589.                 if(algorithm==null) {
  590.                     throw new UtilsException(SECRET_SIGNATURE_ALGO_UNDEFINED);
  591.                 }
  592.                 byte[] encoded = secret.getBytes();
  593.                 JwsSignatureProvider provider = JwsUtils.getHmacSignatureProvider(encoded, algorithm);
  594.                 if(provider==null) {
  595.                     throw new UtilsException("(Secret) JwsSignatureProvider init failed; check signature algorithm ("+algorithm+")");
  596.                 }
  597.                 return provider;
  598.             }
  599.         }
  600.         return null;
  601.     }
  602.     
  603.     // ** INIZIO METODI PER OTTENERE UN JwsSignatureProvider CON PKCS11
  604.     public static JwsSignatureProvider getJwsAsymmetricProvider(Properties props) throws UtilsException {
  605.         String algorithm = props.getProperty(RSSecurityConstants.RSSEC_SIGNATURE_ALGORITHM);
  606.         return getJwsAsymmetricProvider(props, algorithm);
  607.     }
  608.     public static JwsSignatureProvider getJwsAsymmetricProvider(Properties props, String algorithm) throws UtilsException {
  609.         org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm algo = null;
  610.         if(algorithm!=null && !"".equals(algorithm)) {
  611.             algo = org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm.getAlgorithm(algorithm);
  612.         }
  613.         return getJwsAsymmetricProvider(props, algo);
  614.     }
  615.     public static JwsSignatureProvider getJwsAsymmetricProvider(Properties props, org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm algorithm) throws UtilsException {
  616.         String type = props.getProperty(RSSecurityConstants.RSSEC_KEY_STORE_TYPE);
  617.         if(type==null || "".equals(type)) {
  618.             type="undefined";
  619.         }
  620.         if(algorithm==null) {
  621.             throw new UtilsException("("+type+") Signature Algorithm undefined");
  622.         }
  623.         PrivateKey pKey = KeyManagementUtils.loadPrivateKey(null, props, KeyOperation.SIGN);
  624.         return getJwsAsymmetricProvider(pKey, algorithm);
  625.     }
  626.     public static JwsSignatureProvider getJwsAsymmetricProvider(PrivateKey pKey, org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm algorithm) {
  627.         return new PrivateKeyJwsSignatureProvider(pKey, algorithm);
  628.     }
  629.     // ** FINE METODI PER OTTENERE UN JwsSignatureProvider CON PKCS11
  630.     
  631.     public static JwsSignatureVerifier getJwsSignatureVerifier(Properties props) throws UtilsException {
  632.         String algorithm = props.getProperty(RSSecurityConstants.RSSEC_SIGNATURE_ALGORITHM);
  633.         return getJwsSignatureVerifier(props, algorithm);
  634.     }
  635.     public static JwsSignatureVerifier getJwsSignatureVerifier(Properties props, String algorithm) throws UtilsException {
  636.         org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm algo = null;
  637.         if(algorithm==null || "".equals(algorithm)) {
  638.             String type = props.getProperty(RSSecurityConstants.RSSEC_KEY_STORE_TYPE);
  639.             if(KeystoreType.JCEKS.getNome().equalsIgnoreCase(type)) {
  640.                 throw new UtilsException(JCEKS_SIGNATURE_ALGO_UNDEFINED);
  641.             }
  642.         }
  643.         else {
  644.             algo = org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm.getAlgorithm(algorithm);
  645.         }
  646.         return getJwsSignatureVerifier(props, algo);
  647.     }
  648.     public static JwsSignatureVerifier getJwsSignatureVerifier(Properties props, org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm algorithm) throws UtilsException {
  649.         
  650.         SecretKey secretKey = getSecretKey(props);
  651.         if(secretKey!=null) {
  652.             if(algorithm==null) {
  653.                 throw new UtilsException(JCEKS_SIGNATURE_ALGO_UNDEFINED);
  654.             }
  655.             JwsSignatureVerifier verifier = JwsUtils.getHmacSignatureVerifier(secretKey.getEncoded(), algorithm);
  656.             if(verifier==null) {
  657.                 throw new UtilsException("(JCEKS) JwsSignatureVerifier init failed; check signature algorithm ("+algorithm+")");
  658.             }
  659.             return verifier;
  660.         }
  661.         else {
  662.             String secret = getSecret(props, algorithm);
  663.             if(secret!=null) {
  664.                 if(algorithm==null) {
  665.                     throw new UtilsException(SECRET_SIGNATURE_ALGO_UNDEFINED);
  666.                 }
  667.                 byte[] encoded = secret.getBytes();
  668.                 JwsSignatureVerifier verifier = JwsUtils.getHmacSignatureVerifier(encoded, algorithm);
  669.                 if(verifier==null) {
  670.                     throw new UtilsException("(Secret) JwsSignatureVerifier init failed; check signature algorithm ("+algorithm+")");
  671.                 }
  672.                 return verifier;
  673.             }
  674.         }
  675.         return null;
  676.     }
  677.     
  678.     
  679.     
  680.     public static JweEncryptionProvider getJweEncryptionProvider(Properties props) throws UtilsException {
  681.         String algorithm = props.getProperty(JoseConstants.RSSEC_ENCRYPTION_CONTENT_ALGORITHM);
  682.         return getJweEncryptionProvider(props, algorithm);
  683.     }
  684.     public static JweEncryptionProvider getJweEncryptionProvider(Properties props, String algorithm) throws UtilsException {
  685.         org.apache.cxf.rs.security.jose.jwa.ContentAlgorithm algo = null;
  686.         if(algorithm==null || "".equals(algorithm)) {
  687.             String type = props.getProperty(RSSecurityConstants.RSSEC_KEY_STORE_TYPE);
  688.             if(KeystoreType.JCEKS.getNome().equalsIgnoreCase(type)) {
  689.                 throw new UtilsException(JCEKS_CONTENT_ALGO_UNDEFINED);
  690.             }
  691.         }
  692.         else {
  693.             algo = org.apache.cxf.rs.security.jose.jwa.ContentAlgorithm.getAlgorithm(algorithm);
  694.         }
  695.         return getJweEncryptionProvider(props, algo);
  696.     }
  697.     public static JweEncryptionProvider getJweEncryptionProvider(Properties props, org.apache.cxf.rs.security.jose.jwa.ContentAlgorithm algorithm) throws UtilsException {
  698.         
  699.         SecretKey secretKey = getSecretKey(props);
  700.         if(secretKey!=null) {
  701.             if(algorithm==null) {
  702.                 throw new UtilsException(JCEKS_CONTENT_ALGO_UNDEFINED);
  703.             }
  704.             JweEncryptionProvider provider = JweUtils.getDirectKeyJweEncryption(secretKey, algorithm);
  705.             if(provider==null) {
  706.                 throw new UtilsException("(JCEKS) JweEncryptionProvider init failed; check content algorithm ("+algorithm+")");
  707.             }
  708.             return provider;
  709.         }
  710.         return null;
  711.     }
  712.     
  713.     public static JweDecryptionProvider getJweDecryptionProvider(Properties props) throws UtilsException {
  714.         String algorithm = props.getProperty(JoseConstants.RSSEC_ENCRYPTION_CONTENT_ALGORITHM);
  715.         return getJweDecryptionProvider(props, algorithm);
  716.     }
  717.     public static JweDecryptionProvider getJweDecryptionProvider(Properties props, String algorithm) throws UtilsException {
  718.         org.apache.cxf.rs.security.jose.jwa.ContentAlgorithm algo = null;
  719.         if(algorithm==null || "".equals(algorithm)) {
  720.             String type = props.getProperty(RSSecurityConstants.RSSEC_KEY_STORE_TYPE);
  721.             if(KeystoreType.JCEKS.getNome().equalsIgnoreCase(type)) {
  722.                 throw new UtilsException(JCEKS_CONTENT_ALGO_UNDEFINED);
  723.             }
  724.         }
  725.         else {
  726.             algo = org.apache.cxf.rs.security.jose.jwa.ContentAlgorithm.getAlgorithm(algorithm);
  727.         }
  728.         return getJweDecryptionProvider(props, algo);
  729.     }
  730.     public static JweDecryptionProvider getJweDecryptionProvider(Properties props, org.apache.cxf.rs.security.jose.jwa.ContentAlgorithm algorithm) throws UtilsException {
  731.         
  732.         SecretKey secretKey = getSecretKey(props);
  733.         if(secretKey!=null) {
  734.             if(algorithm==null) {
  735.                 throw new UtilsException(JCEKS_CONTENT_ALGO_UNDEFINED);
  736.             }
  737.             JweDecryptionProvider verifier = JweUtils.getDirectKeyJweDecryption(secretKey, algorithm);
  738.             if(verifier==null) {
  739.                 throw new UtilsException("(JCEKS) JweDecryptionProvider init failed; check content algorithm ("+algorithm+")");
  740.             }
  741.             return verifier;
  742.         }
  743.         return null;
  744.     }
  745.     
  746.     // ** INIZIO METODI PER OTTENERE UN JweDecryptionProvider CON PKCS11
  747.     public static JweDecryptionProvider getJweAsymmetricDecryptionProvider(Properties props) throws UtilsException {
  748.         String  contentAlgorithm = props.getProperty(JoseConstants.RSSEC_ENCRYPTION_CONTENT_ALGORITHM);
  749.         String  keyAlgorithm = props.getProperty(JoseConstants.RSSEC_ENCRYPTION_KEY_ALGORITHM);
  750.         return getJweAsymmetricDecryptionProvider(props, keyAlgorithm, contentAlgorithm);
  751.     }
  752.     public static JweDecryptionProvider getJweAsymmetricDecryptionProvider(Properties props, String keyAlgorithm, String contentAlgorithm) throws UtilsException {
  753.         org.apache.cxf.rs.security.jose.jwa.ContentAlgorithm contentAlgo = null;
  754.         if(contentAlgorithm!=null && !"".equals(contentAlgorithm)) {
  755.             contentAlgo = org.apache.cxf.rs.security.jose.jwa.ContentAlgorithm.getAlgorithm(contentAlgorithm);
  756.         }
  757.         org.apache.cxf.rs.security.jose.jwa.KeyAlgorithm keyAlgo = null;
  758.         if(keyAlgorithm!=null && !"".equals(keyAlgorithm)) {
  759.             keyAlgo = org.apache.cxf.rs.security.jose.jwa.KeyAlgorithm.getAlgorithm(keyAlgorithm);
  760.         }
  761.         return getJweAsymmetricDecryptionProvider(props, keyAlgo, contentAlgo);
  762.     }
  763.     public static JweDecryptionProvider getJweAsymmetricDecryptionProvider(Properties props, 
  764.             org.apache.cxf.rs.security.jose.jwa.KeyAlgorithm keyAlgorithm,
  765.             org.apache.cxf.rs.security.jose.jwa.ContentAlgorithm contentAlgorithm) throws UtilsException {
  766.         String type = props.getProperty(RSSecurityConstants.RSSEC_KEY_STORE_TYPE);
  767.         if(type==null || "".equals(type)) {
  768.             type="undefined";
  769.         }
  770.         if(contentAlgorithm==null) {
  771.             throw new UtilsException("("+type+") Content Algorithm undefined");
  772.         }
  773.         if(keyAlgorithm==null) {
  774.             throw new UtilsException("("+type+") Key Algorithm undefined");
  775.         }
  776.         PrivateKey privateKey = KeyManagementUtils.loadPrivateKey(null, props, KeyOperation.DECRYPT);
  777.         return getJweAsymmetricDecryptionProvider(privateKey, keyAlgorithm, contentAlgorithm);
  778.     }
  779.     public static JweDecryptionProvider getJweAsymmetricDecryptionProvider(PrivateKey privateKey,
  780.             org.apache.cxf.rs.security.jose.jwa.KeyAlgorithm keyAlgorithm,
  781.             org.apache.cxf.rs.security.jose.jwa.ContentAlgorithm contentAlgorithm) {
  782.         WrappedKeyDecryptionAlgorithm privateKeyDecryptionProvider = new WrappedKeyDecryptionAlgorithm(privateKey, keyAlgorithm, false);
  783.         return JweUtils.createJweDecryptionProvider(privateKeyDecryptionProvider, contentAlgorithm);
  784.     }
  785.     // ** FINE METODI PER OTTENERE UN JweDecryptionProvider CON PKCS11
  786.     
  787.     public static JweEncryptionProvider getJweEncryptionProviderFromJWKSymmetric(Properties props, JweHeaders headers) {

  789.         // Metodo copiato da JweUtils per risolvere il problema indicato sotto.
  790.         
  791.         Message m = PhaseInterceptorChain.getCurrentMessage();
  792.         
  793.         KeyEncryptionProvider keyEncryptionProvider = JweUtils.loadKeyEncryptionProvider(props, m, headers);
  794.         ContentAlgorithm contentAlgo = JweUtils.getContentEncryptionAlgorithm(m, props, null, ContentAlgorithm.A128GCM);
  795.         if (m != null) {
  796.             m.put(JoseConstants.RSSEC_ENCRYPTION_CONTENT_ALGORITHM, contentAlgo.getJwaName());
  797.         }
  798.         ContentEncryptionProvider ctEncryptionProvider = null;
  799.         JsonWebKey jwk = JwkUtils.loadJsonWebKey(m, props, KeyOperation.ENCRYPT);
  800.         // FIX 
  801.         if(jwk.getAlgorithm()==null) {
  802.             jwk.setAlgorithm(contentAlgo.getJwaName());
  803.         }
  804.         // FIX
  805.         contentAlgo = JweUtils.getContentEncryptionAlgorithm(m, props,
  806.                 jwk.getAlgorithm() != null ? ContentAlgorithm.getAlgorithm(jwk.getAlgorithm()) : null, contentAlgo);
  807.         ctEncryptionProvider = JweUtils.getContentEncryptionProvider(jwk, contentAlgo);
  808.         String compression = props.getProperty(JoseConstants.RSSEC_ENCRYPTION_ZIP_ALGORITHM);
  809.        
  810.         headers = headers != null ? headers : new JweHeaders();
  811.         headers.setKeyEncryptionAlgorithm(keyEncryptionProvider.getAlgorithm());
  812.         headers.setContentEncryptionAlgorithm(contentAlgo);
  813.         if (compression != null) {
  814.             headers.setZipAlgorithm(compression);
  815.         }
  816.         
  817.         return new JweEncryption(keyEncryptionProvider, ctEncryptionProvider);
  818.         
  819.     }
  820.     
  821.     public static JweDecryptionProvider getJweDecryptionProviderFromJWKSymmetric(Properties props, JweHeaders headers) {

  823.         // Metodo copiato da JweUtils per risolvere il problema indicato sotto.
  824.         
  825.         if(headers!=null) {
  826.             // nop
  827.         }
  828.         
  829.         Message m = PhaseInterceptorChain.getCurrentMessage();
  830.         
  831.         JsonWebKey jwk = JwkUtils.loadJsonWebKey(m, props, KeyOperation.DECRYPT);

  833.         ContentAlgorithm contentAlgo = JweUtils.getContentEncryptionAlgorithm(m, props,
  834.                                          ContentAlgorithm.getAlgorithm(jwk.getAlgorithm()),
  835.                                          ContentAlgorithm.A128GCM);
  836.         // FIX 
  837.         if(jwk.getAlgorithm()==null) {
  838.             jwk.setAlgorithm(contentAlgo.getJwaName());
  839.         }
  840.         // FIX
  841.         
  842.         SecretKey ctDecryptionKey = JweUtils.getContentDecryptionSecretKey(jwk, contentAlgo.getJwaName());

  844.         return JweUtils.getDirectKeyJweDecryption(ctDecryptionKey, contentAlgo);
  845.     }
  846.     
  847.     private static String getErrorNonValido(Exception e) {
  848.         return "non valido: "+e.getMessage();
  849.     }
  850.     
  851.     public static void validate(CertificateInfo certificatoInfo,
  852.             KeyStore trustStoreCertificatiX509, CertStore crlX509, IOCSPValidator ocspValidatorX509, String headerName,
  853.             boolean verifaCA,
  854.             CertificateValidityCheck validityCheck) throws UtilsException {
  855.         if(trustStoreCertificatiX509!=null) {
  856.             String prefisso = headerName!=null ? ("Certificato presente nell'header '"+headerName+"' ") : "Certificato di firma ";
  857.             if(verifaCA && !certificatoInfo.isVerified(trustStoreCertificatiX509, true)) {
  858.                 throw new UtilsException(prefisso+"non รจ verificabile rispetto alle CA conosciute");
  859.             }
  860.             if(validityCheck==null // default
  861.                     ||
  862.                     CertificateValidityCheck.ENABLED.equals(validityCheck)
  863.                     ||
  864.                     (CertificateValidityCheck.IF_NOT_IN_TRUSTSTORE.equals(validityCheck) && !trustStoreCertificatiX509.existsCertificateBySubject(certificatoInfo.getCertificate().getSubjectX500Principal()))
  865.                 ) {
  866.                 try {
  867.                     certificatoInfo.checkValid();
  868.                 }catch(CertificateExpiredException e) {
  869.                     throw new UtilsException(prefisso+"scaduto: "+e.getMessage(),e);
  870.                 }catch(CertificateNotYetValidException e) {
  871.                     throw new UtilsException(prefisso+"non ancora valido: "+e.getMessage(),e);
  872.                 }catch(Exception e) {
  873.                     throw new UtilsException(prefisso+getErrorNonValido(e),e);
  874.                 }
  875.             }
  876.             if(ocspValidatorX509!=null) {
  877.                 try {
  878.                     ocspValidatorX509.valid(certificatoInfo.getCertificate());
  879.                 }catch(Exception e) {
  880.                     throw new UtilsException(prefisso+getErrorNonValido(e),e);
  881.                 }
  882.             }
  883.             if(crlX509!=null) {
  884.                 try {
  885.                     certificatoInfo.checkValid(crlX509, trustStoreCertificatiX509);
  886.                 }catch(Exception e) {
  887.                     throw new UtilsException(prefisso+getErrorNonValido(e),e);
  888.                 }
  889.             }
  890.         }
  891.     }
  892.     
  893.  }
Created with JaCoCo 0.8.8.202204050719