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

  24. import java.io.File;
  25. import java.security.PrivateKey;
  26. import java.security.cert.CertStore;
  27. import java.security.cert.Certificate;
  28. import java.security.cert.X509Certificate;
  29. import java.security.interfaces.RSAPublicKey;
  30. import java.util.Enumeration;
  31. import java.util.List;
  32. import java.util.Map;
  33. import java.util.Properties;

  35. import org.apache.cxf.rs.security.jose.jwa.KeyAlgorithm;
  36. import org.apache.cxf.rs.security.jose.jwe.JweCompactConsumer;
  37. import org.apache.cxf.rs.security.jose.jwe.JweDecryptionOutput;
  38. import org.apache.cxf.rs.security.jose.jwe.JweDecryptionProvider;
  39. import org.apache.cxf.rs.security.jose.jwe.JweException;
  40. import org.apache.cxf.rs.security.jose.jwe.JweHeaders;
  41. import org.apache.cxf.rs.security.jose.jwe.JweJsonConsumer;
  42. import org.apache.cxf.rs.security.jose.jwe.JweUtils;
  43. import org.apache.cxf.rs.security.jose.jwk.JsonWebKey;
  44. import org.apache.cxf.rs.security.jose.jwk.JsonWebKeys;
  45. import org.apache.cxf.rs.security.jose.jwk.JwkUtils;
  46. import org.apache.cxf.rt.security.rs.RSSecurityConstants;
  47. import org.openspcoop2.utils.UtilsException;
  48. import org.openspcoop2.utils.certificate.ArchiveLoader;
  49. import org.openspcoop2.utils.certificate.CertificateInfo;
  50. import org.openspcoop2.utils.certificate.JWKSet;
  51. import org.openspcoop2.utils.certificate.KeyStore;
  52. import org.openspcoop2.utils.io.Base64Utilities;
  53. import org.openspcoop2.utils.resources.FileSystemUtilities;
  54. import org.openspcoop2.utils.transport.http.HttpResponse;
  55. import org.openspcoop2.utils.transport.http.HttpUtilities;
  56. import org.openspcoop2.utils.transport.http.IOCSPValidator;

  58. /** 
  59.  * Encrypt
  60.  *
  61.  * @author Poli Andrea (apoli@link.it)
  62.  * @author $Author$
  63.  * @version $Rev$, $Date$
  64.  */
  65. public class JsonDecrypt {

  67.     private JweDecryptionProvider provider;
  68.     private JWTOptions options;
  69.     private Properties properties;
  70.     private boolean dynamicProvider;
  71.     
  72.     private String decodedPayload;
  73.     private byte[] decodedPayloadAsByte;
  74.     
  75.     private JsonWebKeys jsonWebKeys; // dove prendere la chiave privata
  76.     private KeyStore keyStore; // dove prendere la chiave privata
  77.     private Map<String, String> keystoreMapAliasPassword;
  78.     private KeyStore trustStoreVerificaCertificatiX509; // per verificare i certificati presenti nell'header 
  79.     public void setTrustStoreVerificaCertificatiX509(KeyStore trustStoreVerificaCertificatiX509) {
  80.         this.trustStoreVerificaCertificatiX509 = trustStoreVerificaCertificatiX509;
  81.     }
  82.     public KeyStore getTrustStoreVerificaCertificatiX509() {
  83.         return this.trustStoreVerificaCertificatiX509;
  84.     }

  86.     private KeyStore trustStoreHttps; // per accedere ad un endpoint https dove scaricare i certificati
  87.     public KeyStore getTrustStoreHttps() {
  88.         return this.trustStoreHttps;
  89.     }
  90.     private CertStore crlHttps; // per verificare i certificati http server rispetto alle crl
  91.     public void setCrlHttps(CertStore crlHttps) {
  92.         this.crlHttps = crlHttps;
  93.     }
  94.     private IOCSPValidator ocspValidatorHttps; // per verificare i certificati http server rispetto a servizi OCSP
  95.     public void setOcspValidatorHttps(IOCSPValidator ocspValidator) {
  96.         this.ocspValidatorHttps = ocspValidator;
  97.     }
  98.         
  99.     private CertStore crlX509; // per verificare i certificati rispetto alle crl
  100.     public void setCrlX509(CertStore crlX509) {
  101.         this.crlX509 = crlX509;
  102.     }
  103.     private IOCSPValidator ocspValidatorX509; // per verificare i certificati rispetto a servizi OCSP
  104.     public void setOcspValidatorX509(IOCSPValidator ocspValidator) {
  105.         this.ocspValidatorX509 = ocspValidator;
  106.     }
  107.     
  108.     private CertificateValidityCheck validityCheck = CertificateValidityCheck.ENABLED; // validazione (date) del certificato utilizzato per firmare il token    
  109.     public void setValidityCheck(CertificateValidityCheck validityCheck) {
  110.         this.validityCheck = validityCheck;
  111.     }
  112.     
  113.     private boolean jksPasswordRequired=true;
  114.     private boolean pkcs12PasswordRequired=true;
  115.     public void setJksPasswordRequired(boolean jksPasswordRequired) {
  116.         this.jksPasswordRequired = jksPasswordRequired;
  117.     }
  118.     public void setPkcs12PasswordRequired(boolean pkcs12PasswordRequired) {
  119.         this.pkcs12PasswordRequired = pkcs12PasswordRequired;
  120.     }   
  121.     
  122.     public JsonDecrypt(Properties props, JWTOptions options) throws UtilsException{
  123.         this(props, options, true, true);
  124.     }
  125.     public JsonDecrypt(Properties props, JWTOptions options, boolean jksPasswordRequired, boolean pkcs12PasswordRequired) throws UtilsException{
  126.         try {
  127.             this.jksPasswordRequired = jksPasswordRequired;
  128.             this.pkcs12PasswordRequired = pkcs12PasswordRequired;
  129.             this.dynamicProvider = JsonUtils.isDynamicProvider(props); // rimuove l'alias
  130.             if(this.dynamicProvider) {
  131.                 this.properties = props;
  132.             }
  133.             else {
  134.                 this.provider = this.loadProviderFromProperties(props, null); // nel caso di jceks deve essere definito l'algoritmo del contenuto se non e' dinamico
  135.             }
  136.             this.options=options;       
  137.         }catch(Exception t) {
  138.             throw JsonUtils.convert(options.getSerialization(), JsonUtils.DECRYPT,JsonUtils.RECEIVER,t);
  139.         }
  140.     }
  141.     
  142.     private JweDecryptionProvider loadProviderFromProperties(Properties props, org.apache.cxf.rs.security.jose.jwa.ContentAlgorithm contentAlgorithm) throws UtilsException {
  143.         File fTmp = null;
  144.         try {
  145.             fTmp = JsonUtils.normalizeProperties(props); // in caso di url http viene letta la risorsa remota e salvata in tmp
  146.             /**java.util.Enumeration<?> en = props.keys();
  147.             while (en.hasMoreElements()) {
  148.                 String key = (String) en.nextElement();
  149.                 System.out.println("- ["+key+"] ["+props.getProperty(key)+"]");
  150.             }*/
  151.             
  152.             JweDecryptionProvider providerBuild = buildProviderFromProperties(props, contentAlgorithm);
  153.             
  154.             try {
  155.                 Certificate cert = JsonUtils.getCertificateKey(this.jksPasswordRequired,this.pkcs12PasswordRequired,props);
  156.                 if(cert instanceof X509Certificate) {
  157.                     this.x509Certificate = (X509Certificate) cert;
  158.                 }
  159.             }catch(Exception t) {
  160.                 // ignore
  161.             }
  162.             
  163.             return providerBuild;
  164.              
  165.         }finally {
  166.             FileSystemUtilities.deleteFile(fTmp);
  167.         }
  168.     }
  169.     private JweDecryptionProvider buildProviderFromProperties(Properties props, org.apache.cxf.rs.security.jose.jwa.ContentAlgorithm contentAlgorithm) throws UtilsException {
  170.         JweDecryptionProvider providerBuild = null;
  171.         if(contentAlgorithm!=null) {
  172.             providerBuild = JsonUtils.getJweDecryptionProvider(props, contentAlgorithm);
  173.         }
  174.         else {
  175.             providerBuild = JsonUtils.getJweDecryptionProvider(props);
  176.         }
  177.         if(providerBuild==null) {
  178.             providerBuild = buildProviderFromProperties(props);
  179.         }
  180.         if(providerBuild==null) {
  181.             throw new UtilsException("JweDecryptionProvider provider not found");
  182.         }
  183.         return providerBuild;
  184.     }
  185.     private JweDecryptionProvider buildProviderFromProperties(Properties props) throws UtilsException {
  186.         JweDecryptionProvider providerBuild = null;
  187.         KeyAlgorithm keyAlgorithm = JweUtils.getKeyEncryptionAlgorithm(props, null);
  188.         if (KeyAlgorithm.DIRECT.equals(keyAlgorithm)) {
  189.             providerBuild = JsonUtils.getJweDecryptionProviderFromJWKSymmetric(props, null);
  190.         }
  191.         else {
  192.             try {
  193.                 providerBuild = JweUtils.loadDecryptionProvider(props, JsonUtils.newMessage(), null); // lasciare null come secondo parametro senno non funziona il decrypt senza keyEncoding
  194.             }catch(JweException jweExc) {
  195.                 if(jweExc.getMessage()!=null && jweExc.getMessage().contains("NO_ENCRYPTOR")) {
  196.                     // caso in cui la chiave privata PKCS11 non e' stata mappata in un PrivateKeyDecryptionProvider
  197.                     providerBuild = JsonUtils.getJweAsymmetricDecryptionProvider(props);
  198.                     if(providerBuild==null) {
  199.                         // rilancio eccezione precedente
  200.                         throw jweExc;
  201.                     }
  202.                 }
  203.             }
  204.         }
  205.         return providerBuild;
  206.     }
  207.     
  208.     public JsonDecrypt(java.security.KeyStore keystore, String alias, String passwordPrivateKey, String keyAlgorithm, String contentAlgorithm, JWTOptions options) throws UtilsException{
  209.         this(new KeyStore(keystore), false, alias, passwordPrivateKey, keyAlgorithm, contentAlgorithm, options);
  210.     }
  211.     public JsonDecrypt(KeyStore keystore, String alias, String passwordPrivateKey, String keyAlgorithm, String contentAlgorithm, JWTOptions options) throws UtilsException{
  212.         this(keystore, false, alias, passwordPrivateKey, keyAlgorithm, contentAlgorithm, options);
  213.     }
  214.     public JsonDecrypt(java.security.KeyStore keystore, boolean secretKey, String alias, String passwordPrivateKey, String keyAlgorithm, String contentAlgorithm, JWTOptions options) throws UtilsException{
  215.         this(new KeyStore(keystore), secretKey, alias, passwordPrivateKey, keyAlgorithm, contentAlgorithm, options);
  216.     }
  217.     public JsonDecrypt(KeyStore keystore, boolean secretKey, String alias, String passwordPrivateKey, String keyAlgorithm, String contentAlgorithm, JWTOptions options) throws UtilsException{
  218.         try {
  219.             this.options=options;
  220.             
  221.             org.apache.cxf.rs.security.jose.jwa.KeyAlgorithm keyAlgo  = org.apache.cxf.rs.security.jose.jwa.KeyAlgorithm.getAlgorithm(keyAlgorithm);
  222.             org.apache.cxf.rs.security.jose.jwa.ContentAlgorithm contentAlgo = org.apache.cxf.rs.security.jose.jwa.ContentAlgorithm.getAlgorithm(contentAlgorithm);
  223.             if(secretKey) {
  224.                 
  225.                 if (KeyAlgorithm.DIRECT.equals(keyAlgo)) {
  226.                     this.provider = JweUtils.getDirectKeyJweDecryption(keystore.getSecretKey(alias, passwordPrivateKey), contentAlgo);
  227.                 }
  228.                 else {
  229.                     this.provider = JweUtils.createJweDecryptionProvider( keystore.getSecretKey(alias, passwordPrivateKey), keyAlgo, contentAlgo);
  230.                 }

  232.             }else {
  233.                 PrivateKey privateKey = keystore.getPrivateKey(alias, passwordPrivateKey);
  234.                 this.provider = JweUtils.createJweDecryptionProvider( privateKey, keyAlgo, contentAlgo);
  235.                 checkKeyAlgorithm();
  236.                 if(this.provider==null) {
  237.                     this.provider = JsonUtils.getJweAsymmetricDecryptionProvider(privateKey, keyAlgo, contentAlgo);
  238.                     if(this.provider==null) {
  239.                         throw new UtilsException("("+keystore.getKeystore().getType()+") JwsDecryptionProvider init failed; keyAlgorithm ("+keyAlgorithm+") contentAlgorithm("+contentAlgorithm+")");
  240.                     }
  241.                 }   
  242.             }
  243.             
  244.             setSafeCertificate(keystore, alias);
  245.             
  246.         }catch(Exception t) {
  247.             throw JsonUtils.convert(options.getSerialization(), JsonUtils.DECRYPT,JsonUtils.RECEIVER,t);
  248.         }
  249.     }
  250.     private void setSafeCertificate(KeyStore keystore, String alias) {
  251.         try {
  252.             Certificate cert = keystore.getCertificate(alias);
  253.             if(cert instanceof X509Certificate) {
  254.                 this.x509Certificate = (X509Certificate) cert;
  255.             }
  256.         }catch(Exception t) {
  257.             // ignore
  258.         }
  259.     }
  260.     private void checkKeyAlgorithm() {
  261.         try {
  262.             this.provider.getKeyAlgorithm();
  263.         }catch(NullPointerException nullPointer) {
  264.             // caso in cui la chiave privata PKCS11 non e' stata mappata in un PrivateKeyDecryptionProvider
  265.             this.provider = null;
  266.         }
  267.     }
  268.     
  269.     
  270.     public JsonDecrypt(JsonWebKeys jsonWebKeys, boolean secretKey, String alias, String keyAlgorithm, String contentAlgorithm, JWTOptions options) throws UtilsException{
  271.         this(JsonUtils.readKey(jsonWebKeys, alias),secretKey, keyAlgorithm, contentAlgorithm, options);
  272.     }
  273.     public JsonDecrypt(JsonWebKey jsonWebKey, boolean secretKey, String keyAlgorithm, String contentAlgorithm, JWTOptions options) throws UtilsException{
  274.         try {
  275.             this.options=options;
  276.             
  277.             org.apache.cxf.rs.security.jose.jwa.KeyAlgorithm keyAlgo  = org.apache.cxf.rs.security.jose.jwa.KeyAlgorithm.getAlgorithm(keyAlgorithm);
  278.             org.apache.cxf.rs.security.jose.jwa.ContentAlgorithm contentAlgo = org.apache.cxf.rs.security.jose.jwa.ContentAlgorithm.getAlgorithm(contentAlgorithm);
  279.             
  280.             if(secretKey) {
  281.                 if(jsonWebKey.getAlgorithm()==null) {
  282.                     jsonWebKey.setAlgorithm(contentAlgorithm);
  283.                 }
  284.                 if (KeyAlgorithm.DIRECT.equals(keyAlgo)) {
  285.                     this.provider = JweUtils.getDirectKeyJweDecryption(JwkUtils.toSecretKey(jsonWebKey), contentAlgo);
  286.                 }
  287.                 else {
  288.                     this.provider = JweUtils.createJweDecryptionProvider( JwkUtils.toSecretKey(jsonWebKey), keyAlgo, contentAlgo);
  289.                 }
  290.                 if(this.provider==null) {
  291.                     throw new UtilsException("(JsonWebKey) JwsDecryptionProvider init failed; check content algorithm ("+contentAlgorithm+")");
  292.                 }
  293.             }else {
  294.                 this.provider = JweUtils.createJweDecryptionProvider( JwkUtils.toRSAPrivateKey(jsonWebKey), keyAlgo, contentAlgo);
  295.             }

  297.         }catch(Exception t) {
  298.             throw JsonUtils.convert(options.getSerialization(), JsonUtils.DECRYPT,JsonUtils.RECEIVER,t);
  299.         }
  300.     }
  301.     
  302.     


  305.     public JsonDecrypt(Properties propsTrustStoreHttps, java.security.KeyStore trustStoreVerificaCertificato, 
  306.             java.security.KeyStore keyStore, Map<String, String> keystoreMapAliasPassword, 
  307.             JWTOptions options) {
  308.         initDecryptHeaderJWTEngine(propsTrustStoreHttps, null, 
  309.                 new KeyStore(trustStoreVerificaCertificato), 
  310.                 new KeyStore(keyStore), keystoreMapAliasPassword,
  311.                 options);
  312.     }
  313.     public JsonDecrypt(KeyStore trustStoreHttps, java.security.KeyStore trustStoreVerificaCertificato, 
  314.             java.security.KeyStore keyStore, Map<String, String> keystoreMapAliasPassword, 
  315.             JWTOptions options) {
  316.         initDecryptHeaderJWTEngine(null, trustStoreHttps, 
  317.                 new KeyStore(trustStoreVerificaCertificato), 
  318.                 new KeyStore(keyStore), keystoreMapAliasPassword,
  319.                 options);
  320.     }
  321.     public JsonDecrypt(Properties propsTrustStoreHttps, KeyStore trustStore, 
  322.             KeyStore keyStore, Map<String, String> keystoreMapAliasPassword, 
  323.             JWTOptions options) {
  324.         initDecryptHeaderJWTEngine(propsTrustStoreHttps, null, 
  325.                 trustStore, 
  326.                 keyStore, keystoreMapAliasPassword,
  327.                 options);
  328.     }
  329.     public JsonDecrypt(KeyStore trustStoreHttps, KeyStore trustStore, 
  330.             KeyStore keyStore, Map<String, String> keystoreMapAliasPassword, 
  331.             JWTOptions options) {
  332.         initDecryptHeaderJWTEngine(null, trustStoreHttps, 
  333.                 trustStore, 
  334.                 keyStore, keystoreMapAliasPassword,
  335.                 options);
  336.     }
  337.     public JsonDecrypt(java.security.KeyStore trustStoreVerificaCertificato, 
  338.             java.security.KeyStore keyStore, Map<String, String> keystoreMapAliasPassword, 
  339.             JWTOptions options) {
  340.         initDecryptHeaderJWTEngine(null, null, 
  341.                 new KeyStore(trustStoreVerificaCertificato), 
  342.                 new KeyStore(keyStore), keystoreMapAliasPassword,
  343.                 options);
  344.     }
  345.     public JsonDecrypt(KeyStore trustStore, 
  346.             KeyStore keyStore, Map<String, String> keystoreMapAliasPassword, 
  347.             JWTOptions options) {
  348.         initDecryptHeaderJWTEngine(null, null, 
  349.                 trustStore, 
  350.                 keyStore, keystoreMapAliasPassword,
  351.                 options);
  352.     }
  353.     private void initDecryptHeaderJWTEngine(Properties propsTrustStoreHttps, KeyStore trustStoreHttps,
  354.             KeyStore trustStoreVerificaCertificato, 
  355.             KeyStore keyStore, Map<String, String> keystoreMapAliasPassword, 
  356.             JWTOptions options) {
  357.         // verra usato l'header per validare ed ottenere il certificato
  358.         this.options=options;
  359.         this.properties = propsTrustStoreHttps; // le proprieta' servono per risolvere le url https
  360.         this.trustStoreHttps = trustStoreHttps;
  361.         this.trustStoreVerificaCertificatiX509 = trustStoreVerificaCertificato;
  362.         this.keyStore = keyStore;
  363.         this.keystoreMapAliasPassword = keystoreMapAliasPassword;
  364.     }
  365.     
  366.     
  367.     public JsonDecrypt(Properties propsTrustStoreHttps, JsonWebKeys jsonWebKeys, 
  368.             JWTOptions options) {
  369.         initDecryptHeaderJWTEngine(propsTrustStoreHttps, null,
  370.                 jsonWebKeys,
  371.                 options);
  372.     }
  373.     public JsonDecrypt(KeyStore trustStoreHttps, JsonWebKeys jsonWebKeys, 
  374.             JWTOptions options) {
  375.         initDecryptHeaderJWTEngine(null, trustStoreHttps,
  376.                 jsonWebKeys,
  377.                 options);
  378.     }
  379.     public JsonDecrypt(JsonWebKeys jsonWebKeys, 
  380.             JWTOptions options) {
  381.         initDecryptHeaderJWTEngine(null, null, 
  382.                 jsonWebKeys,
  383.                 options);
  384.     }
  385.     private void initDecryptHeaderJWTEngine(Properties propsTrustStoreHttps, KeyStore trustStoreHttps,
  386.             JsonWebKeys jsonWebKeys, 
  387.             JWTOptions options) {
  388.         // verra usato l'header per validare ed ottenere il certificato
  389.         this.options=options;
  390.         this.properties = propsTrustStoreHttps; // le proprieta' servono per risolvere le url https
  391.         this.trustStoreHttps = trustStoreHttps;
  392.         this.jsonWebKeys = jsonWebKeys;
  393.     }
  394.     
  395.     


  398.     public void decrypt(String jsonString) throws UtilsException{
  399.         try {
  400.             switch(this.options.getSerialization()) {
  401.                 case JSON: decryptJson(jsonString); break;
  402.                 case COMPACT: decryptCompact(jsonString); break;
  403.                 default: throw new UtilsException("Unsupported serialization '"+this.options.getSerialization()+"'");
  404.             }
  405.         }
  406.         catch(Exception t) {
  407.             throw JsonUtils.convert(this.options.getSerialization(), JsonUtils.DECRYPT,JsonUtils.RECEIVER,t);
  408.         }
  409.     }
  410.     

  412.     private void decryptCompact(String jsonString) throws UtilsException {
  413.         
  414.         JweCompactConsumer consumer = new JweCompactConsumer(jsonString);
  415.         JweHeaders jweHeaders = consumer.getJweHeaders();
  416.         
  417.         JweDecryptionProvider providerBuild = getProvider(jweHeaders, null);
  418.         
  419.         JweDecryptionOutput output =  providerBuild.decrypt(jsonString);
  420.         this.decodedPayload = output.getContentText();
  421.         this.decodedPayloadAsByte = output.getContent();
  422.     }


  425.     private void decryptJson(String jsonString) throws UtilsException {
  426.         
  427.         JweJsonConsumer consumer = new JweJsonConsumer(jsonString);
  428.         JweHeaders jweHeaders = consumer.getProtectedHeader();
  429.         JweHeaders jweUnprotectedHeaders = consumer.getSharedUnprotectedHeader();
  430.         
  431.         JweDecryptionProvider providerBuild = getProvider(jweHeaders, jweUnprotectedHeaders);
  432.         
  433.         // con gestione recipients
  434. /**     org.apache.cxf.rs.security.jose.jwe.JweJsonEncryptionEntry entry = consumer.getRecipients().get(0);
  435. //      JweDecryptionOutput output = consumer.decryptWith(provider, entry);*/
  436.         
  437.         // senza gestione recipients
  438.         JweDecryptionOutput output = consumer.decryptWith(providerBuild);
  439.         
  440.         this.decodedPayload = output.getContentText();
  441.         this.decodedPayloadAsByte = output.getContent();
  442.         
  443.     }

  445.     public String getDecodedPayload() {
  446.         return this.decodedPayload;
  447.     }

  449.     public byte[] getDecodedPayloadAsByte() {
  450.         return this.decodedPayloadAsByte;
  451.     }
  452.     
  453.     
  454.     private X509Certificate x509Certificate;
  455.     private RSAPublicKey rsaPublicKey;
  456.     private String kid;
  457.     public X509Certificate getX509Certificate() {
  458.         return this.x509Certificate;
  459.     }
  460.     public RSAPublicKey getRsaPublicKey() {
  461.         return this.rsaPublicKey;
  462.     }
  463.     public String getKid() {
  464.         return this.kid;
  465.     }
  466.     
  467.     private JweDecryptionProvider getProvider(JweHeaders jweHeaders, JweHeaders jweUnprotectedHeaders) throws UtilsException {
  468.         
  469.         JweDecryptionProvider providerBuild = this.provider;
  470.         if(jweHeaders==null) {
  471.             return providerBuild;
  472.         }
  473.         
  474.         if(this.dynamicProvider) {
  475.             /**String alias = JsonUtils.readAlias(jsonString);*/
  476.             String alias = jweHeaders.getKeyId();
  477.             Properties pNew = new Properties();
  478.             pNew.putAll(this.properties);
  479.             /**System.out.println("ALIAS ["+alias+"]");*/
  480.             pNew.put(RSSecurityConstants.RSSEC_KEY_STORE_ALIAS, alias);
  481.             providerBuild = loadProviderFromProperties(pNew, jweHeaders.getContentEncryptionAlgorithm());
  482.         }
  483.         
  484.         if(providerBuild==null) {
  485.             org.apache.cxf.rs.security.jose.jwa.KeyAlgorithm keyAlgo  = jweHeaders.getKeyEncryptionAlgorithm();
  486.             if(keyAlgo==null && jweUnprotectedHeaders!=null) {
  487.                 keyAlgo = jweUnprotectedHeaders.getKeyEncryptionAlgorithm();
  488.             }
  489.             if(keyAlgo==null) {
  490.                 throw new UtilsException("KeyAlgorithm not found");
  491.             }
  492.             
  493.             org.apache.cxf.rs.security.jose.jwa.ContentAlgorithm contentAlgo = jweHeaders.getContentEncryptionAlgorithm();
  494.             if(contentAlgo==null) {
  495.                 throw new UtilsException("ContentAlgorithm not found");
  496.             }
  497.             
  498.             if(jweHeaders.getX509Chain()!=null && !jweHeaders.getX509Chain().isEmpty() && this.options.isPermitUseHeaderX5C()) {
  499.                 // This parameter has the same meaning, syntax, and processing rules as
  500.                 //   the "x5c" Header Parameter defined in Section 4.1.6 of [JWS], except
  501.                 //   that the X.509 public key certificate or certificate chain [RFC5280]
  502.                 //   contains the public key to which the JWE was encrypted; this can be
  503.                 //   used to determine the private key needed to decrypt the JWE.
  504.                 try {
  505.                     byte [] cer = Base64Utilities.decode(jweHeaders.getX509Chain().get(0));
  506.                     CertificateInfo certificatoInfo = ArchiveLoader.load(cer).getCertificate();
  507.                     if(this.trustStoreVerificaCertificatiX509!=null) {
  508.                         JsonUtils.validate(certificatoInfo, 
  509.                                 this.trustStoreVerificaCertificatiX509, this.crlX509, this.ocspValidatorX509, JwtHeaders.JWT_HDR_X5C, true,
  510.                                 this.validityCheck);
  511.                     }
  512.                     providerBuild = getProviderX509(certificatoInfo, keyAlgo, contentAlgo);
  513.                 }catch(Exception e) {
  514.                     throw new UtilsException("Process '"+JwtHeaders.JWT_HDR_X5C+"' error: "+e.getMessage(),e);
  515.                 }
  516.             }
  517.             else if(jweHeaders.getJsonWebKey()!=null && this.options.isPermitUseHeaderJWK()) {
  518.                 // This parameter has the same meaning, syntax, and processing rules as
  519.                 //   the "jwk" Header Parameter defined in Section 4.1.3 of [JWS], except
  520.                 //   that the key is the public key to which the JWE was encrypted; this
  521.                 //   can be used to determine the private key needed to decrypt the JWE.
  522.                 try {
  523.                     JsonWebKey webKey = jweHeaders.getJsonWebKey();
  524.                     providerBuild = getProviderJWK(webKey, keyAlgo, contentAlgo);
  525.                 }catch(Exception e) {
  526.                     throw new UtilsException("Process '"+JwtHeaders.JWT_HDR_JWK+"' error: "+e.getMessage(),e);
  527.                 }
  528.             }
  529.             else if(
  530.                     (jweHeaders.getX509Url()!=null && this.options.isPermitUseHeaderX5U()) 
  531.                     ||
  532.                     (jweHeaders.getJsonWebKeysUrl()!=null && this.options.isPermitUseHeaderJKU())
  533.                     ) {
  534.             
  535.                 boolean x509 = true;
  536.                 String path = jweHeaders.getX509Url();
  537.                 String hdr = JwtHeaders.JWT_HDR_X5U;
  538.                 if(path==null) {
  539.                     path=jweHeaders.getJsonWebKeysUrl();
  540.                     x509 = false;
  541.                     hdr = JwtHeaders.JWT_HDR_JKU;
  542.                 }
  543.                 try {
  544.                     byte [] cer = null;
  545.                     if(this.properties!=null) {
  546.                         this.properties.put(RSSecurityConstants.RSSEC_KEY_STORE_FILE, path);
  547.                         cer = JsonUtils.readKeystoreFromURI(this.properties);
  548.                     }
  549.                     else {
  550.                         HttpResponse httpResponse = null;
  551.                         try {
  552.                             if(this.trustStoreHttps!=null) {
  553.                                 httpResponse = HttpUtilities.getHTTPSResponse(path, this.trustStoreHttps.getKeystore(), this.crlHttps, this.ocspValidatorHttps);
  554.                             }
  555.                             else {
  556.                                 httpResponse = HttpUtilities.getHTTPResponse(path);
  557.                             }
  558.                         }catch(Exception e) {
  559.                             throw new UtilsException("Resource '"+path+"' unavailable: "+e.getMessage(),e);
  560.                         }
  561.                         if(httpResponse==null || httpResponse.getContent()==null) {
  562.                             throw new UtilsException("Resource '"+path+"' unavailable");
  563.                         }
  564.                         if(httpResponse.getResultHTTPOperation()!=200) {
  565.                             throw new UtilsException("Retrieve '"+path+"' failed (returnCode:"+httpResponse.getResultHTTPOperation()+")");
  566.                         }
  567.                         cer = httpResponse.getContent();
  568.                     }
  569.                     if(cer==null) {
  570.                         throw new UtilsException("Resource '"+path+"' unavailable");
  571.                     }
  572.                     
  573.                     if(x509) {
  574.                         CertificateInfo certificatoInfo = ArchiveLoader.load(cer).getCertificate();
  575.                         if(this.trustStoreVerificaCertificatiX509!=null) {
  576.                             JsonUtils.validate(certificatoInfo, 
  577.                                     this.trustStoreVerificaCertificatiX509, this.crlX509, this.ocspValidatorX509, JwtHeaders.JWT_HDR_X5U, true,
  578.                                     this.validityCheck);
  579.                         }
  580.                         providerBuild = getProviderX509(certificatoInfo, keyAlgo, contentAlgo);
  581.                     }
  582.                     else {
  583.                         JWKSet set = new JWKSet(new String(cer));
  584.                         JsonWebKeys jsonWebKeysBuild = set.getJsonWebKeys();
  585.                         JsonWebKey jsonWebKey = null;
  586.                         if(jsonWebKeysBuild.size()==1) {
  587.                             jsonWebKey = jsonWebKeysBuild.getKeys().get(0);
  588.                         }
  589.                         else {
  590.                             if(jweHeaders.getKeyId()==null) {
  591.                                 throw new UtilsException("Kid non definito e JwkSet contiene più di un certificato");
  592.                             }
  593.                             jsonWebKey = jsonWebKeysBuild.getKey(jweHeaders.getKeyId());
  594.                         }
  595.                         if(jsonWebKey==null) {
  596.                             throw new UtilsException("JsonWebKey non trovata");
  597.                         }
  598.                         providerBuild = getProviderJWK(jsonWebKey, keyAlgo, contentAlgo);
  599.                     }
  600.                 }catch(Exception e) {
  601.                     throw new UtilsException("Process '"+hdr+"' error: "+e.getMessage(),e);
  602.                 }
  603.             }
  604.             else if(jweHeaders.getKeyId()!=null && this.options.isPermitUseHeaderKID()) {
  605.                 // This parameter has the same meaning, syntax, and processing rules as
  606.                 //   the "kid" Header Parameter defined in Section 4.1.4 of [JWS], except
  607.                 //   that the key hint references the public key to which the JWE was
  608.                 //   encrypted; this can be used to determine the private key needed to
  609.                 //   decrypt the JWE.  This parameter allows originators to explicitly
  610.                 //   signal a change of key to JWE recipients.
  611.                 try {
  612.                     this.kid = jweHeaders.getKeyId();
  613.                     if(this.jsonWebKeys!=null) {
  614.                         JsonWebKey jsonWebKey = null;
  615.                         try {
  616.                             jsonWebKey = this.jsonWebKeys.getKey(this.kid);
  617.                         }catch(Exception e) {
  618.                             // key non esistente
  619.                         }
  620.                         if(jsonWebKey!=null) {
  621.                             providerBuild = getProviderJWK(jsonWebKey, keyAlgo, contentAlgo);
  622.                         }
  623.                     }
  624.                     if(providerBuild==null &&
  625.                         this.keyStore!=null &&
  626.                         this.keyStore.existsAlias(this.kid)) {
  627.                         Certificate cer = this.keyStore.getCertificate(this.kid);
  628.                         if(cer instanceof X509Certificate) {
  629.                             X509Certificate x509CertificateBuild = (X509Certificate) cer;
  630.                             
  631.                             // La validazione serve per verificare la data e il crl
  632.                             if(this.trustStoreVerificaCertificatiX509!=null) {
  633.                                 JsonUtils.validate(new CertificateInfo(x509CertificateBuild, this.kid), 
  634.                                         this.trustStoreVerificaCertificatiX509, this.crlX509, this.ocspValidatorX509, JwtHeaders.JWT_HDR_KID, false,
  635.                                         this.validityCheck);
  636.                             }
  637.                             else {
  638.                                 JsonUtils.validate(new CertificateInfo(x509CertificateBuild, this.kid), 
  639.                                         this.keyStore, this.crlX509, this.ocspValidatorX509, JwtHeaders.JWT_HDR_KID, false,
  640.                                         this.validityCheck);
  641.                             }
  642.                             
  643.                             CertificateInfo certificatoInfo = new CertificateInfo(x509CertificateBuild, this.kid);
  644.                             providerBuild = getProviderX509(certificatoInfo, keyAlgo, contentAlgo);
  645.                         }
  646.                     }
  647.                 }catch(Exception e) {
  648.                     throw new UtilsException("Process '"+JwtHeaders.JWT_HDR_KID+"' error: "+e.getMessage(),e);
  649.                 }
  650.             }
  651.             else if(
  652.                     (jweHeaders.getX509ThumbprintSHA256()!=null && this.options.isPermitUseHeaderX5T_256())
  653.                     ||
  654.                     (jweHeaders.getX509Thumbprint()!=null && this.options.isPermitUseHeaderX5T())
  655.                     ) {
  656.                 String hdr = JwtHeaders.JWT_HDR_X5T;
  657.                 if (jweHeaders.getX509ThumbprintSHA256()!=null) {
  658.                     hdr = JwtHeaders.JWT_HDR_X5t_S256;
  659.                 }
  660.                 try {
  661.                     if(this.keyStore==null) {
  662.                         throw new UtilsException("KeyStore dei certificati non fornito"); 
  663.                     }
  664.                     Certificate cer = null;
  665.                     if(jweHeaders.getX509ThumbprintSHA256()!=null) {
  666.                         cer = this.keyStore.getCertificateByDigestSHA256UrlEncoded(jweHeaders.getX509ThumbprintSHA256());
  667.                     }
  668.                     else{
  669.                         cer = this.keyStore.getCertificateByDigestSHA1UrlEncoded(jweHeaders.getX509Thumbprint());
  670.                     }
  671.                     if(cer==null) {
  672.                         throw new UtilsException("Certificato, corrispondente al digest indicato, non trovato nel KeyStore dei certificati");
  673.                     }
  674.                     if(cer instanceof X509Certificate) {
  675.                         X509Certificate x509CertificateBuild = (X509Certificate) cer;
  676.                         
  677.                         // La validazione serve per verificare la data e il crl
  678.                         if(this.trustStoreVerificaCertificatiX509!=null) {
  679.                             JsonUtils.validate(new CertificateInfo(x509CertificateBuild, hdr), 
  680.                                     this.trustStoreVerificaCertificatiX509, this.crlX509, this.ocspValidatorX509, hdr, false,
  681.                                     this.validityCheck);
  682.                         }
  683.                         else {
  684.                             JsonUtils.validate(new CertificateInfo(x509CertificateBuild, hdr), 
  685.                                     this.keyStore, this.crlX509, this.ocspValidatorX509, hdr, false,
  686.                                     this.validityCheck);
  687.                         }
  688.                         
  689.                         CertificateInfo certificatoInfo = new CertificateInfo(x509CertificateBuild, "x5t");
  690.                         providerBuild = getProviderX509(certificatoInfo, keyAlgo, contentAlgo);
  691.                     }
  692.                     else {
  693.                         throw new UtilsException("Certificato indicato non è nel formato X.509");
  694.                     }
  695.                 }catch(Exception e) {
  696.                     throw new UtilsException("Process '"+hdr+"' error: "+e.getMessage(),e);
  697.                 }
  698.             }
  699.             else {
  700.                 List<String> hdrNotPermitted = this.options.headersNotPermitted(jweHeaders);
  701.                 String notPermitted = "";
  702.                 if(hdrNotPermitted!=null && !hdrNotPermitted.isEmpty()) {
  703.                     notPermitted = "; header trovati ma non abilitati all'utilizzo: "+hdrNotPermitted;
  704.                 }
  705.                 throw new UtilsException("Non è stato trovato alcun header che consentisse di recuperare il certificato per decifrare"+notPermitted);
  706.             }
  707.         }
  708.         else {
  709.             if(this.x509Certificate!=null && this.trustStoreVerificaCertificatiX509!=null) {
  710.                 try {
  711.                     CertificateInfo certificatoInfo = new CertificateInfo(this.x509Certificate, "x509");
  712.                     JsonUtils.validate(certificatoInfo, 
  713.                             this.trustStoreVerificaCertificatiX509, this.crlX509, this.ocspValidatorX509, null, true,
  714.                             this.validityCheck);
  715.                 }catch(Exception e) {
  716.                     throw new UtilsException(e.getMessage(),e);
  717.                 }
  718.             }
  719.         }
  720.         
  721.         return providerBuild;
  722.     }
  723.     
  724.     private JweDecryptionProvider getProviderX509(CertificateInfo certificatoInfo,
  725.             org.apache.cxf.rs.security.jose.jwa.KeyAlgorithm keyAlgo,
  726.             org.apache.cxf.rs.security.jose.jwa.ContentAlgorithm contentAlgo) throws UtilsException {
  727.         if(this.keyStore==null) {
  728.             throw new UtilsException("Keystore da utilizzare per il recupero dei certificati non definito");
  729.         }
  730.         if(this.keystoreMapAliasPassword==null) {
  731.             throw new UtilsException("Mappping alias-password non definito");
  732.         }
  733.         this.x509Certificate = certificatoInfo.getCertificate();
  734.         PrivateKey privateKey = null;
  735.         Enumeration<String> aliases = this.keyStore.aliases();
  736.         while (aliases.hasMoreElements()) {
  737.             String alias = aliases.nextElement();
  738.             Certificate certificateCheck = this.keyStore.getCertificate(alias);
  739.             if(certificateCheck instanceof X509Certificate) {
  740.                 X509Certificate x509CertificateCheck = (X509Certificate) certificateCheck;
  741.                 if(certificatoInfo.equals(x509CertificateCheck, true)) {
  742.                     try {
  743.                         String passwordPrivateKey = this.keystoreMapAliasPassword.get(alias);
  744.                         if(passwordPrivateKey==null) {
  745.                             throw new UtilsException("password non definita");
  746.                         }
  747.                         privateKey = this.keyStore.getPrivateKey(alias, passwordPrivateKey);
  748.                     }catch(Exception e) {
  749.                         throw new UtilsException("Chiave privata associato al certificato (alias: "+alias+") non recuperabile: "+e.getMessage(),e);
  750.                     }
  751.                 }
  752.             }
  753.         }
  754.         if(privateKey==null) {
  755.             throw new UtilsException("Chiave privata associato al certificato (presente in header x5c) non recuperato");
  756.         }
  757.         JweDecryptionProvider providerBuild = JweUtils.createJweDecryptionProvider( privateKey, keyAlgo, contentAlgo);
  758.         try {
  759.             providerBuild.getKeyAlgorithm();
  760.         }catch(NullPointerException nullPointer) {
  761.             // caso in cui la chiave privata PKCS11 non e' stata mappata in un PrivateKeyDecryptionProvider
  762.             providerBuild = null;
  763.         }
  764.         if(providerBuild==null) {
  765.             providerBuild = JsonUtils.getJweAsymmetricDecryptionProvider(privateKey, keyAlgo, contentAlgo);
  766.             if(providerBuild==null) {
  767.                 throw new UtilsException("JwsDecryptionProvider init failed; keyAlgorithm ("+keyAlgo+") contentAlgorithm("+contentAlgo+")");
  768.             }
  769.         }
  770.         return providerBuild;

  772.     }
  773.     
  774.     private JweDecryptionProvider getProviderJWK(JsonWebKey webKey,
  775.             org.apache.cxf.rs.security.jose.jwa.KeyAlgorithm keyAlgo,
  776.             org.apache.cxf.rs.security.jose.jwa.ContentAlgorithm contentAlgo) throws UtilsException {
  777.         String n = webKey.getStringProperty("n");
  778.         if(n==null) {
  779.             throw new UtilsException("JsonWebKey uncorrect? 'n' not found");
  780.         }
  781.         if(this.jsonWebKeys==null) {
  782.             throw new UtilsException("JWKSet da utilizzare per il recupero dei certificati non definito");
  783.         }
  784.         this.rsaPublicKey = JwkUtils.toRSAPublicKey(webKey);
  785.         List<JsonWebKey> keys = this.jsonWebKeys.getKeys();
  786.         if(keys==null || keys.isEmpty()) {
  787.             throw new UtilsException("JWKSet da utilizzare per il recupero dei certificati vuoto");
  788.         }
  789.         JsonWebKey privateKey = null;
  790.         for (JsonWebKey jsonWebKeyCheck : keys) {
  791.             String nCheck = jsonWebKeyCheck.getStringProperty("n");
  792.             if(nCheck!=null && nCheck.equals(n)) {
  793.                 privateKey = jsonWebKeyCheck;
  794.                 break;
  795.             }
  796.         }
  797.         return JweUtils.createJweDecryptionProvider( JwkUtils.toRSAPrivateKey(privateKey), keyAlgo, contentAlgo);
  798.     }
  799. }
Created with JaCoCo 0.8.8.202204050719