JsonVerifySignature.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.PublicKey;
  26. import java.security.cert.CertStore;
  27. import java.security.cert.Certificate;
  28. import java.security.cert.X509Certificate;
  29. import java.util.List;
  30. import java.util.Properties;

  32. import org.apache.cxf.common.util.Base64UrlUtility;
  33. import org.apache.cxf.rs.security.jose.jwk.JsonWebKey;
  34. import org.apache.cxf.rs.security.jose.jwk.JsonWebKeys;
  35. import org.apache.cxf.rs.security.jose.jwk.JwkUtils;
  36. import org.apache.cxf.rs.security.jose.jws.JwsCompactConsumer;
  37. import org.apache.cxf.rs.security.jose.jws.JwsHeaders;
  38. import org.apache.cxf.rs.security.jose.jws.JwsJsonConsumer;
  39. import org.apache.cxf.rs.security.jose.jws.JwsJsonProducer;
  40. import org.apache.cxf.rs.security.jose.jws.JwsSignatureVerifier;
  41. import org.apache.cxf.rs.security.jose.jws.JwsUtils;
  42. import org.apache.cxf.rt.security.rs.RSSecurityConstants;
  43. import org.openspcoop2.utils.UtilsException;
  44. import org.openspcoop2.utils.certificate.ArchiveLoader;
  45. import org.openspcoop2.utils.certificate.CertificateInfo;
  46. import org.openspcoop2.utils.certificate.JWK;
  47. import org.openspcoop2.utils.certificate.JWKSet;
  48. import org.openspcoop2.utils.certificate.KeyStore;
  49. import org.openspcoop2.utils.certificate.remote.IRemoteStoreProvider;
  50. import org.openspcoop2.utils.certificate.remote.RemoteKeyType;
  51. import org.openspcoop2.utils.certificate.remote.RemoteStoreConfig;
  52. import org.openspcoop2.utils.io.Base64Utilities;
  53. import org.openspcoop2.utils.transport.http.HttpResponse;
  54. import org.openspcoop2.utils.transport.http.HttpUtilities;
  55. import org.openspcoop2.utils.transport.http.IOCSPValidator;

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

  66.     private JwsSignatureVerifier provider;
  67.     private Properties propsConfig;
  68.     private JWTOptions options;
  69.     private Properties properties;
  70.     private boolean dynamicProvider;
  71.     
  72.     private JwsHeaders jwsDecodedHeaders;
  73.     private String decodedHeader;
  74.     
  75.     private String decodedPayload;
  76.     private byte[] decodedPayloadAsByte;
  77.     
  78.     private KeyStore trustStoreCertificatiX509; // per verificare i certificati presenti nell'header
  79.     public KeyStore getTrustStoreCertificatiX509() {
  80.         return this.trustStoreCertificatiX509;
  81.     }
  82.     private JsonWebKeys jsonWebKeys; // dove prendere il certificato per validare rispetto al kid
  83.     
  84.     private IRemoteStoreProvider remoteStoreProvider; // dove prendere il certificato remoto per validare rispetto al kid
  85.     private RemoteKeyType remoteStoreKeyType; 
  86.     private RemoteStoreConfig remoteStoreConfig;
  87.     
  88.     private KeyStore trustStoreHttps; // per accedere ad un endpoint https dove scaricare i certificati
  89.     public KeyStore getTrustStoreHttps() {
  90.         return this.trustStoreHttps;
  91.     }
  92.     private CertStore crlHttps; // per verificare i certificati http server rispetto alle crl
  93.     public void setCrlHttps(CertStore crlHttps) {
  94.         this.crlHttps = crlHttps;
  95.     }
  96.     private IOCSPValidator ocspValidatorHttps; // per verificare i certificati http server rispetto a servizi OCSP
  97.     public void setOcspValidatorHttps(IOCSPValidator ocspValidator) {
  98.         this.ocspValidatorHttps = ocspValidator;
  99.     }
  100.     
  101.     private CertStore crlX509; // per verificare i certificati rispetto alle crl
  102.     public void setCrlX509(CertStore crlX509) {
  103.         this.crlX509 = crlX509;
  104.     }
  105.     private IOCSPValidator ocspValidatorX509; // per verificare i certificati rispetto a servizi OCSP
  106.     public void setOcspValidatorX509(IOCSPValidator ocspValidator) {
  107.         this.ocspValidatorX509 = ocspValidator;
  108.     }

  110.     private CertificateValidityCheck validityCheck = CertificateValidityCheck.ENABLED; // validazione (date) del certificato utilizzato per firmare il token    
  111.     public void setValidityCheck(CertificateValidityCheck validityCheck) {
  112.         this.validityCheck = validityCheck;
  113.     }
  114.     
  115.     private boolean jksPasswordRequired=true;
  116.     private boolean pkcs12PasswordRequired=true;
  117.     public void setJksPasswordRequired(boolean jksPasswordRequired) {
  118.         this.jksPasswordRequired = jksPasswordRequired;
  119.     }
  120.     public void setPkcs12PasswordRequired(boolean pkcs12PasswordRequired) {
  121.         this.pkcs12PasswordRequired = pkcs12PasswordRequired;
  122.     }   

  124.     public JsonVerifySignature(Properties props, JWTOptions options) throws UtilsException{
  125.         try {
  126.             this.propsConfig = props;
  127.             this.dynamicProvider = JsonUtils.isDynamicProvider(props); // rimuove l'alias
  128.             if(this.dynamicProvider) {
  129.                 this.properties = props;
  130.             }
  131.             else {
  132.                 this.provider = loadProviderFromProperties(props, null); // nel caso di jceks deve essere definito l'algoritmo se non e' dinamico
  133.             }
  134.             this.options = options;
  135.         }catch(Exception t) {
  136.             throw JsonUtils.convert(options.getSerialization(), JsonUtils.SIGNATURE,JsonUtils.RECEIVER,t);
  137.         }
  138.     }

  140.     private JwsSignatureVerifier loadProviderFromProperties(Properties props, org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm signatureAlgorithm) throws UtilsException {
  141.         File fTmp = null;
  142.         try {
  143.             fTmp = JsonUtils.normalizeProperties(props); // in caso di url http viene letta la risorsa remota e salvata in tmp
  144.             /**java.util.Enumeration<?> en = props.keys();
  145.             while (en.hasMoreElements()) {
  146.                 String key = (String) en.nextElement();
  147.                 System.out.println("- ["+key+"] ["+props.getProperty(key)+"]");
  148.             }*/
  149.             
  150.             JwsSignatureVerifier providerReturn = null;
  151.             if(signatureAlgorithm!=null) {
  152.                 providerReturn = JsonUtils.getJwsSignatureVerifier(props, signatureAlgorithm);
  153.             }
  154.             else {
  155.                 providerReturn = JsonUtils.getJwsSignatureVerifier(props);
  156.             }
  157.             if(providerReturn==null) {
  158.                 providerReturn = JwsUtils.loadSignatureVerifier(JsonUtils.newMessage(), props, new JwsHeaders());
  159.             }
  160.             if(providerReturn==null) {
  161.                 throw new UtilsException("JwsSignatureVerifier provider not found");
  162.             }
  163.             return providerReturn;
  164.         }finally {
  165.             try {
  166.                 if(fTmp!=null) {
  167.                     java.nio.file.Files.delete(fTmp.toPath());
  168.                 }
  169.             }catch(Exception t) {
  170.                 // ignore
  171.             }
  172.         }
  173.     }
  174.     
  175.     public JsonVerifySignature(java.security.KeyStore keystore, String alias, String signatureAlgorithm, JWTOptions options) throws UtilsException{
  176.         this(new KeyStore(keystore), alias, signatureAlgorithm, options);
  177.     }
  178.     public JsonVerifySignature(KeyStore keystore, String alias, String signatureAlgorithm, JWTOptions options) throws UtilsException{
  179.         try {
  180.             org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm algo = org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm.getAlgorithm(signatureAlgorithm);
  181.             this.provider = JwsUtils.getPublicKeySignatureVerifier((X509Certificate) keystore.getCertificate(alias), algo);
  182.             this.options=options;
  183.             
  184.             this.trustStoreCertificatiX509 = keystore; // per abilitare la validazione crl o ocsp
  185.             
  186.         }catch(Exception t) {
  187.             throw JsonUtils.convert(options.getSerialization(), JsonUtils.SIGNATURE,JsonUtils.RECEIVER,t);
  188.         }
  189.     }
  190.     
  191.     public JsonVerifySignature(java.security.KeyStore keystore, String alias, String passwordPrivateKey, String signatureAlgorithm, JWTOptions options) throws UtilsException{
  192.         this(new KeyStore(keystore), alias, passwordPrivateKey, signatureAlgorithm, options);
  193.     }
  194.     public JsonVerifySignature(KeyStore keystore, String alias, String passwordPrivateKey, String signatureAlgorithm, JWTOptions options) throws UtilsException{
  195.         try {
  196.             org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm algo = org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm.getAlgorithm(signatureAlgorithm);
  197.             this.provider = JwsUtils.getHmacSignatureVerifier(keystore.getSecretKey(alias, passwordPrivateKey).getEncoded(), algo);
  198.             if(this.provider==null) {
  199.                 throw new UtilsException("(JCEKS) JwsSignatureVerifier init failed; check signature algorithm ("+signatureAlgorithm+")");
  200.             }
  201.             this.options=options;
  202.             
  203.             this.trustStoreCertificatiX509 = keystore; // per abilitare la validazione crl o ocsp
  204.             
  205.         }catch(Exception t) {
  206.             throw JsonUtils.convert(options.getSerialization(), JsonUtils.SIGNATURE,JsonUtils.RECEIVER,t);
  207.         }
  208.     }
  209.     
  210.     public JsonVerifySignature(JsonWebKeys jsonWebKeys, boolean secretKey, String alias, String signatureAlgorithm, JWTOptions options) throws UtilsException{
  211.         this(JsonUtils.readKey(jsonWebKeys, alias), secretKey, signatureAlgorithm, options);
  212.     }   
  213.     public JsonVerifySignature(JsonWebKey jsonWebKey, boolean secretKey, String signatureAlgorithm, JWTOptions options) throws UtilsException{
  214.         try {
  215.             org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm algo = org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm.getAlgorithm(signatureAlgorithm);
  216.             if(secretKey) {
  217.                 this.provider = JwsUtils.getSignatureVerifier(jsonWebKey, algo);
  218.                 if(this.provider==null) {
  219.                     throw new UtilsException("(JsonWebKey) JwsSignatureVerifier init failed; check signature algorithm ("+signatureAlgorithm+")");
  220.                 }
  221.             }
  222.             else {
  223.                 this.provider = JwsUtils.getPublicKeySignatureVerifier(JwkUtils.toRSAPublicKey(jsonWebKey), algo);
  224.             }
  225.             this.options=options;
  226.         }catch(Exception t) {
  227.             throw JsonUtils.convert(options.getSerialization(), JsonUtils.SIGNATURE,JsonUtils.RECEIVER,t);
  228.         }
  229.     }
  230.     
  231.     public JsonVerifySignature(String secret, String signatureAlgorithm, JWTOptions options) throws UtilsException{
  232.         try {
  233.             org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm algo = org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm.getAlgorithm(signatureAlgorithm);
  234.             this.provider = JwsUtils.getHmacSignatureVerifier(secret.getBytes(), algo);
  235.             if(this.provider==null) {
  236.                 throw new UtilsException("(Secret) JwsSignatureVerifier init failed; check signature algorithm ("+signatureAlgorithm+")");
  237.             }
  238.             this.options=options;
  239.         }catch(Exception t) {
  240.             throw JsonUtils.convert(options.getSerialization(), JsonUtils.SIGNATURE,JsonUtils.RECEIVER,t);
  241.         }
  242.     }
  243.     
  244.     
  245.     public JsonVerifySignature(JWTOptions options) {
  246.         initVerifyCertificatiHeaderJWTEngine(null, null, 
  247.                 null, options);
  248.     }
  249.     public JsonVerifySignature(Properties propsTrustStoreHttps, java.security.KeyStore trustStoreVerificaCertificato, JWTOptions options) {
  250.         initVerifyCertificatiHeaderJWTEngine(propsTrustStoreHttps, null, 
  251.                 new KeyStore(trustStoreVerificaCertificato), options);
  252.     }
  253.     public JsonVerifySignature(Properties propsTrustStoreHttps, KeyStore trustStore, JWTOptions options){
  254.         initVerifyCertificatiHeaderJWTEngine(propsTrustStoreHttps, null,
  255.                 trustStore, options);
  256.     }
  257.     public JsonVerifySignature(java.security.KeyStore trustStoreHttps, java.security.KeyStore trustStoreVerificaCertificato, JWTOptions options) {
  258.         initVerifyCertificatiHeaderJWTEngine(null, new KeyStore(trustStoreHttps), 
  259.                 new KeyStore(trustStoreVerificaCertificato), options);
  260.     }
  261.     public JsonVerifySignature(KeyStore trustStoreHttps, KeyStore trustStore, JWTOptions options) {
  262.         initVerifyCertificatiHeaderJWTEngine(null, trustStoreHttps,
  263.                 trustStore, options);
  264.     }
  265.     public JsonVerifySignature(java.security.KeyStore trustStoreVerificaCertificato, JWTOptions options) {
  266.         initVerifyCertificatiHeaderJWTEngine(null, null, 
  267.                 new KeyStore(trustStoreVerificaCertificato), options);
  268.     }
  269.     public JsonVerifySignature(KeyStore trustStore, JWTOptions options) {
  270.         initVerifyCertificatiHeaderJWTEngine(null, null, 
  271.                 trustStore, options);
  272.     }
  273.     private void initVerifyCertificatiHeaderJWTEngine(Properties propsTrustStoreHttps, KeyStore trustStoreHttps,
  274.             KeyStore trustStoreVerificaCertificato, JWTOptions options) {
  275.         // verra usato l'header per validare ed ottenere il certificato
  276.         this.options=options;
  277.         this.properties = propsTrustStoreHttps; // le proprieta' servono per risolvere le url https
  278.         this.trustStoreHttps = trustStoreHttps;
  279.         this.trustStoreCertificatiX509 = trustStoreVerificaCertificato;
  280.     }
  281.     
  282.     public JsonVerifySignature(JsonWebKeys jsonWebKeys, JWTOptions options) {
  283.         initVerifyCertificatiHeaderJWTEngine(jsonWebKeys, options);
  284.     }
  285.     private void initVerifyCertificatiHeaderJWTEngine(JsonWebKeys jsonWebKeys, JWTOptions options) {
  286.         // verra usato l'header per validare ed ottenere il certificato
  287.         this.options=options;
  288.         this.jsonWebKeys = jsonWebKeys;
  289.     }

  291.     
  292.     public JsonVerifySignature(IRemoteStoreProvider remoteStoreProvider, RemoteKeyType remoteStoreKeyType, RemoteStoreConfig remoteStoreConfig, JWTOptions options) {
  293.         initVerifyCertificatiHeaderRemoteStoreEngine(remoteStoreProvider, remoteStoreKeyType, remoteStoreConfig, options);
  294.     }
  295.     private void initVerifyCertificatiHeaderRemoteStoreEngine(IRemoteStoreProvider remoteStoreProvider, RemoteKeyType remoteStoreKeyType, RemoteStoreConfig remoteStoreConfig, JWTOptions options) {
  296.         // verra usato l'header per validare ed ottenere il certificato
  297.         this.options=options;
  298.         this.remoteStoreProvider = remoteStoreProvider;
  299.         this.remoteStoreKeyType = remoteStoreKeyType;
  300.         this.remoteStoreConfig = remoteStoreConfig;
  301.     }
  302.     

  304.     public boolean verify(String jsonString) throws UtilsException{
  305.         try {
  306.             switch(this.options.getSerialization()) {
  307.                 case JSON: return verifyJson(jsonString);
  308.                 case COMPACT: return verifyCompact(jsonString);
  309.                 default: throw new UtilsException("Unsupported serialization '"+this.options.getSerialization()+"'");
  310.             }
  311.         }
  312.         catch(Exception t) {
  313.             throw JsonUtils.convert(this.options.getSerialization(), JsonUtils.SIGNATURE,JsonUtils.RECEIVER,t);
  314.         }
  315.     }

  317.     public boolean verifyDetached(String jsonDetachedSignature, String jsonDetachedPayload) throws UtilsException{
  318.         try {
  319.             switch(this.options.getSerialization()) {
  320.                 case JSON: return verifyDetachedJson(jsonDetachedSignature, jsonDetachedPayload);
  321.                 case COMPACT: return verifyDetachedCompact(jsonDetachedSignature, jsonDetachedPayload);
  322.                 default: throw new UtilsException("Unsupported serialization '"+this.options.getSerialization()+"'");
  323.             }
  324.         }
  325.         catch(Exception t) {
  326.             throw JsonUtils.convert(this.options.getSerialization(), JsonUtils.SIGNATURE,JsonUtils.RECEIVER,t);
  327.         }
  328.     }

  330.     private boolean verifyDetachedJson(String jsonDetachedSignature, String jsonDetachedPayload) throws UtilsException {
  331.         JwsJsonProducer producer = new JwsJsonProducer(jsonDetachedPayload);
  332.         JwsJsonConsumer consumer = new JwsJsonConsumer(jsonDetachedSignature, producer.getUnsignedEncodedPayload());
  333.         return this.verifyJsonEngine(consumer);
  334.     }
  335.     private boolean verifyJson(String jsonString) throws UtilsException {
  336.         JwsJsonConsumer consumer = new JwsJsonConsumer(jsonString);
  337.         return this.verifyJsonEngine(consumer);
  338.     }   
  339.     private boolean verifyJsonEngine(JwsJsonConsumer consumer) throws UtilsException {
  340.         
  341.         JwsHeaders jwsHeaders = null;
  342.         if(consumer.getSignatureEntries()!=null && !consumer.getSignatureEntries().isEmpty() &&
  343.             // prendo la prima entry
  344.             consumer.getSignatureEntries().get(0)!=null
  345.             ) {
  346.             jwsHeaders = consumer.getSignatureEntries().get(0).getProtectedHeader();
  347.         }
  348.         JwsSignatureVerifier providerInternal = getProvider(jwsHeaders);
  349.         
  350.         boolean result = consumer.verifySignatureWith(providerInternal);
  351.         this.decodedPayload = consumer.getDecodedJwsPayload();
  352.         this.decodedPayloadAsByte = consumer.getDecodedJwsPayloadBytes();
  353.         return result;
  354.     }

  356.     private boolean verifyDetachedCompact(String jsonDetachedSignature, String jsonDetachedPayload) throws UtilsException {
  357.         return verifyCompactEngine(jsonDetachedSignature, jsonDetachedPayload);
  358.     }
  359.     private boolean verifyCompact(String jsonSignature) throws UtilsException {
  360.         return verifyCompactEngine(jsonSignature, null);
  361.     }
  362.     private boolean verifyCompactEngine(String jsonSignature, String jsonDetachedPayload) throws UtilsException {
  363.         
  364.         JwsCompactConsumer consumer = null;
  365.         if(jsonDetachedPayload==null) {
  366.             consumer = new JwsCompactConsumer(jsonSignature);
  367.         }
  368.         else {
  369.             consumer = new JwsCompactConsumer(jsonSignature, Base64UrlUtility.encode(jsonDetachedPayload));
  370.         }
  371.         
  372.         this.jwsDecodedHeaders = consumer.getJwsHeaders();
  373.         try {
  374.             this.decodedHeader = consumer.getDecodedJsonHeaders();
  375.         }catch(Exception e) {
  376.             // ignore
  377.         }
  378.         
  379.         JwsSignatureVerifier providerInternal = getProvider(this.jwsDecodedHeaders);
  380.                 
  381.         boolean result = consumer.verifySignatureWith(providerInternal);
  382.         if(jsonDetachedPayload!=null) {
  383.             this.decodedPayload = jsonDetachedPayload;
  384.             this.decodedPayloadAsByte = jsonDetachedPayload.getBytes();
  385.         }
  386.         else {
  387.             this.decodedPayload = consumer.getDecodedJwsPayload();
  388.             this.decodedPayloadAsByte = consumer.getDecodedJwsPayloadBytes();
  389.         }
  390.         return result;
  391.     }
  392.     
  393.     public String getDecodedPayload() {
  394.         return this.decodedPayload;
  395.     }

  397.     public byte[] getDecodedPayloadAsByte() {
  398.         return this.decodedPayloadAsByte;
  399.     }
  400.     
  401.     public JwsHeaders getJwsDecodedHeaders() {
  402.         return this.jwsDecodedHeaders;
  403.     }
  404.     
  405.     public String getDecodedHeader() {
  406.         return this.decodedHeader;
  407.     }
  408.     
  409.     private X509Certificate x509Certificate;
  410.     private PublicKey publicKey;
  411.     private String kid;
  412.     public X509Certificate getX509Certificate() {
  413.         return this.x509Certificate;
  414.     }
  415.     public PublicKey getRsaPublicKey() {
  416.         return this.publicKey;
  417.     }
  418.     public String getKid() {
  419.         return this.kid;
  420.     }

  422.     private String getProcessErrorMsg(String mode, Exception e) {
  423.         return "Process '"+mode+"' error: "+e.getMessage();
  424.     }
  425.     private JwsSignatureVerifier getProvider(JwsHeaders jwsHeaders) throws UtilsException {
  426.         
  427.         JwsSignatureVerifier providerReturn = this.provider;
  428.         if(jwsHeaders==null) {
  429.             return providerReturn;
  430.         }
  431.                 
  432.         if(this.dynamicProvider) {
  433.             /** String alias = JsonUtils.readAlias(jsonSignature); */
  434.             String alias = jwsHeaders.getKeyId();
  435.             Properties pNew = new Properties();
  436.             pNew.putAll(this.properties);
  437.             /** System.out.println("ALIAS ["+alias+"]"); */
  438.             pNew.put(RSSecurityConstants.RSSEC_KEY_STORE_ALIAS, alias);
  439.             providerReturn = loadProviderFromProperties(pNew, jwsHeaders.getSignatureAlgorithm());
  440.         }
  441.         
  442.         if(providerReturn==null) {
  443.             org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm algo = jwsHeaders.getSignatureAlgorithm();
  444.             if(algo==null) {
  445.                 throw new UtilsException("SignatureAlgorithm not found");
  446.             }
  447.             
  448.             if(jwsHeaders.getX509Chain()!=null && !jwsHeaders.getX509Chain().isEmpty() && this.options.isPermitUseHeaderX5C()) {
  449.                 try {
  450.                     // https://tools.ietf.org/html/rfc7515#section-4.1.6: The certificate containing the public key corresponding to the key used to digitally sign the JWS MUST be the first certificate.
  451.                     byte [] cer = Base64Utilities.decode(jwsHeaders.getX509Chain().get(0));
  452.                     CertificateInfo certificatoInfo = ArchiveLoader.load(cer).getCertificate();
  453.                     if(this.trustStoreCertificatiX509!=null) {
  454.                         JsonUtils.validate(certificatoInfo, 
  455.                                 this.trustStoreCertificatiX509, this.crlX509, this.ocspValidatorX509, JwtHeaders.JWT_HDR_X5C, 
  456.                                 true,
  457.                                 this.validityCheck);
  458.                     }
  459.                     this.x509Certificate = certificatoInfo.getCertificate();
  460.                     providerReturn = JwsUtils.getPublicKeySignatureVerifier(this.x509Certificate, algo);
  461.                 }catch(Exception e) {
  462.                     throw new UtilsException(getProcessErrorMsg(JwtHeaders.JWT_HDR_X5C,e),e);
  463.                 }
  464.             }
  465.             else if(jwsHeaders.getJsonWebKey()!=null && this.options.isPermitUseHeaderJWK()) {
  466.                 try {
  467.                     this.publicKey = JwkUtils.toRSAPublicKey(jwsHeaders.getJsonWebKey());
  468.                     providerReturn = JwsUtils.getPublicKeySignatureVerifier(this.publicKey, algo);
  469.                 }catch(Exception e) {
  470.                     throw new UtilsException(getProcessErrorMsg(JwtHeaders.JWT_HDR_JWK,e),e);
  471.                 }
  472.             }
  473.             else if(
  474.                     (jwsHeaders.getX509Url()!=null && this.options.isPermitUseHeaderX5U()) 
  475.                     ||
  476.                     (jwsHeaders.getJsonWebKeysUrl()!=null && this.options.isPermitUseHeaderJKU())
  477.                     ) {
  478.                 
  479.                 boolean x509 = true;
  480.                 String path = jwsHeaders.getX509Url();
  481.                 String hdr = JwtHeaders.JWT_HDR_X5U;
  482.                 if(path==null) {
  483.                     path=jwsHeaders.getJsonWebKeysUrl();
  484.                     x509 = false;
  485.                     hdr = JwtHeaders.JWT_HDR_JKU;
  486.                 }
  487.                 try {
  488.                     String prefixPath = "Resource '"+path+"'";
  489.                     byte [] cer = null;
  490.                     if(this.properties!=null) {
  491.                         this.properties.put(RSSecurityConstants.RSSEC_KEY_STORE_FILE, path);
  492.                         cer = JsonUtils.readKeystoreFromURI(this.properties);
  493.                     }
  494.                     else {
  495.                         HttpResponse httpResponse = getHttpResponse(path, prefixPath);
  496.                         if(httpResponse==null || httpResponse.getContent()==null) {
  497.                             throw new UtilsException(prefixPath+" unavailable");
  498.                         }
  499.                         if(httpResponse.getResultHTTPOperation()!=200) {
  500.                             throw new UtilsException("Retrieve '"+path+"' failed (returnCode:"+httpResponse.getResultHTTPOperation()+")");
  501.                         }
  502.                         cer = httpResponse.getContent();
  503.                     }
  504.                     if(cer==null) {
  505.                         throw new UtilsException(prefixPath+" unavailable");
  506.                     }
  507.                     if(x509) {
  508.                         CertificateInfo certificatoInfo = ArchiveLoader.load(cer).getCertificate();
  509.                         if(this.trustStoreCertificatiX509!=null) {
  510.                             JsonUtils.validate(certificatoInfo, 
  511.                                     this.trustStoreCertificatiX509, this.crlX509, this.ocspValidatorX509, hdr, 
  512.                                     true,
  513.                                     this.validityCheck);
  514.                         }
  515.                         this.x509Certificate = certificatoInfo.getCertificate();
  516.                         providerReturn = JwsUtils.getPublicKeySignatureVerifier(this.x509Certificate, algo);
  517.                     }
  518.                     else {
  519.                         JWKSet set = new JWKSet(new String(cer));
  520.                         JsonWebKeys jsonWebKeysInternal = set.getJsonWebKeys();
  521.                         JsonWebKey jsonWebKey = null;
  522.                         if(jsonWebKeysInternal.size()==1) {
  523.                             jsonWebKey = jsonWebKeysInternal.getKeys().get(0);
  524.                         }
  525.                         else {
  526.                             if(jwsHeaders.getKeyId()==null) {
  527.                                 throw new UtilsException("Kid non definito e JwkSet contiene più di un certificato");
  528.                             }
  529.                             jsonWebKey = jsonWebKeysInternal.getKey(jwsHeaders.getKeyId());
  530.                         }
  531.                         if(jsonWebKey==null) {
  532.                             throw new UtilsException("JsonWebKey non trovata");
  533.                         }
  534.                         this.publicKey = JwkUtils.toRSAPublicKey(jsonWebKey);
  535.                         providerReturn = JwsUtils.getPublicKeySignatureVerifier(this.publicKey, algo);
  536.                     }
  537.                 }catch(Exception e) {
  538.                     throw new UtilsException(getProcessErrorMsg(hdr,e),e);
  539.                 }
  540.             }
  541.             else if(jwsHeaders.getKeyId()!=null && this.options.isPermitUseHeaderKID()) {
  542.                 try {
  543.                     this.kid = jwsHeaders.getKeyId();
  544.                     if(this.jsonWebKeys!=null) {
  545.                         JsonWebKey jsonWebKey = getJsonWebKeyByKidIgnoreException();
  546.                         if(jsonWebKey!=null) {
  547.                             this.publicKey = JwkUtils.toRSAPublicKey(jsonWebKey);
  548.                             providerReturn = JwsUtils.getPublicKeySignatureVerifier(this.publicKey, algo);
  549.                         }
  550.                     }
  551.                     if(providerReturn==null &&
  552.                         this.trustStoreCertificatiX509!=null &&
  553.                         this.trustStoreCertificatiX509.existsAlias(this.kid)) {
  554.                         Certificate cer = this.trustStoreCertificatiX509.getCertificate(this.kid);
  555.                         if(cer instanceof X509Certificate) {
  556.                             this.x509Certificate = (X509Certificate) cer;
  557.                             
  558.                             // La validazione serve per verificare la data e il crl
  559.                             JsonUtils.validate(new CertificateInfo(this.x509Certificate, this.kid), 
  560.                                     this.trustStoreCertificatiX509, this.crlX509, this.ocspValidatorX509, JwtHeaders.JWT_HDR_KID, 
  561.                                     false,
  562.                                     this.validityCheck);
  563.                             
  564.                             providerReturn = JwsUtils.getPublicKeySignatureVerifier(this.x509Certificate, algo);
  565.                         }
  566.                     }
  567.                     if(providerReturn==null &&
  568.                             this.remoteStoreProvider!=null && this.remoteStoreConfig!=null && this.remoteStoreKeyType!=null) {
  569.                         providerReturn = getProviderByRemoteStore(algo);
  570.                     }
  571.                     if(providerReturn==null) {
  572.                         throw new UtilsException("Certificato, corrispondente al kid '"+this.kid+"', non trovato nel TrustStore dei certificati");
  573.                     }
  574.                 }catch(Exception e) {
  575.                     throw new UtilsException(getProcessErrorMsg(JwtHeaders.JWT_HDR_KID,e),e);
  576.                 }
  577.             }
  578.             else if(
  579.                     (jwsHeaders.getX509ThumbprintSHA256()!=null && this.options.isPermitUseHeaderX5T_256())
  580.                     ||
  581.                     (jwsHeaders.getX509Thumbprint()!=null && this.options.isPermitUseHeaderX5T())
  582.                     ) {
  583.                 String hdr = JwtHeaders.JWT_HDR_X5T;
  584.                 if (jwsHeaders.getX509ThumbprintSHA256()!=null) {
  585.                     hdr = JwtHeaders.JWT_HDR_X5t_S256;
  586.                 }
  587.                 try {
  588.                     if(this.trustStoreCertificatiX509==null) {
  589.                         throw new UtilsException("TrustStore dei certificati non fornito"); 
  590.                     }
  591.                     Certificate cer = null;
  592.                     if(jwsHeaders.getX509ThumbprintSHA256()!=null) {
  593.                         cer = this.trustStoreCertificatiX509.getCertificateByDigestSHA256UrlEncoded(jwsHeaders.getX509ThumbprintSHA256());
  594.                     }
  595.                     else{
  596.                         cer = this.trustStoreCertificatiX509.getCertificateByDigestSHA1UrlEncoded(jwsHeaders.getX509Thumbprint());
  597.                     }
  598.                     if(cer==null) {
  599.                         throw new UtilsException("Certificato, corrispondente al digest indicato, non trovato nel TrustStore dei certificati");
  600.                     }   
  601.                     if(cer instanceof X509Certificate) {
  602.                         this.x509Certificate = (X509Certificate) cer;
  603.                         
  604.                         // La validazione serve per verificare la data e il crl
  605.                         JsonUtils.validate(new CertificateInfo(this.x509Certificate, hdr), 
  606.                                 this.trustStoreCertificatiX509, this.crlX509, this.ocspValidatorX509, hdr, 
  607.                                 false,
  608.                                 this.validityCheck);
  609.                         
  610.                         providerReturn = JwsUtils.getPublicKeySignatureVerifier(this.x509Certificate, algo);
  611.                     }
  612.                     else {
  613.                         throw new UtilsException("Certificato indicato non è nel formato X.509");
  614.                     }
  615.                 }catch(Exception e) {
  616.                     throw new UtilsException(getProcessErrorMsg(hdr,e),e);
  617.                 }
  618.             }
  619.             else {
  620.                 List<String> hdrNotPermitted = this.options.headersNotPermitted(jwsHeaders);
  621.                 String notPermitted = "";
  622.                 if(hdrNotPermitted!=null && !hdrNotPermitted.isEmpty()) {
  623.                     notPermitted = "; header trovati ma non abilitati all'utilizzo: "+hdrNotPermitted;
  624.                 }
  625.                 throw new UtilsException("Non è stato trovato alcun header che consentisse di recuperare il certificato per effettuare la validazione"+notPermitted);
  626.             }
  627.         }
  628.         else {
  629.             if(this.x509Certificate==null && providerReturn instanceof org.apache.cxf.rs.security.jose.jws.PublicKeyJwsSignatureVerifier) {
  630.                 org.apache.cxf.rs.security.jose.jws.PublicKeyJwsSignatureVerifier certVer = (org.apache.cxf.rs.security.jose.jws.PublicKeyJwsSignatureVerifier) providerReturn;
  631.                 this.x509Certificate = certVer.getX509Certificate();
  632.                 
  633.                 KeyStore trustStore = this.trustStoreCertificatiX509;
  634.                 if(trustStore==null &&
  635.                     this.propsConfig!=null) {
  636.                     trustStore = JsonUtils.getKeyStore(this.jksPasswordRequired, this.pkcs12PasswordRequired, this.propsConfig);
  637.                 }
  638.                 
  639.                 if(trustStore!=null) {
  640.                     try {
  641.                         CertificateInfo certificatoInfo = new CertificateInfo(this.x509Certificate, "x509");
  642.                         JsonUtils.validate(certificatoInfo, 
  643.                                 trustStore, this.crlX509, this.ocspValidatorX509, null, true,
  644.                                 this.validityCheck);
  645.                     }catch(Exception e) {
  646.                         throw new UtilsException(e.getMessage(),e);
  647.                     }
  648.                 }
  649.             }
  650.         }
  651.         
  652.         return providerReturn;
  653.     }
  654.     
  655.     private JsonWebKey getJsonWebKeyByKidIgnoreException(){
  656.         try {
  657.             return this.jsonWebKeys.getKey(this.kid);
  658.         }catch(Exception e) {
  659.             // key not found
  660.         }
  661.         return null;
  662.     }
  663.     
  664.     private HttpResponse getHttpResponse(String path, String prefixPath) throws UtilsException{
  665.         HttpResponse httpResponse = null;
  666.         try {
  667.             if(this.trustStoreHttps!=null) {
  668.                 httpResponse = HttpUtilities.getHTTPSResponse(path, this.trustStoreHttps.getKeystore(), this.crlHttps, this.ocspValidatorHttps);
  669.             }
  670.             else {
  671.                 httpResponse = HttpUtilities.getHTTPResponse(path);
  672.             }
  673.         }catch(Exception e) {
  674.             throw new UtilsException(prefixPath+" unavailable: "+e.getMessage(),e);
  675.         }
  676.         return httpResponse;
  677.     }
  678.     
  679.     private JwsSignatureVerifier getProviderByRemoteStore(org.apache.cxf.rs.security.jose.jwa.SignatureAlgorithm algo) throws UtilsException {
  680.         switch (this.remoteStoreKeyType) {
  681.         case JWK:
  682.             JWK jwk = this.remoteStoreProvider.readJWK(this.kid, this.remoteStoreConfig);
  683.             if(jwk==null) {
  684.                 throw this.newUtilsExceptionErrorKidUnavailable(true);
  685.             }
  686.             JsonWebKey jsonWebKey = jwk.getJsonWebKey();
  687.             if(jsonWebKey!=null) {
  688.                 this.publicKey = JwkUtils.toRSAPublicKey(jsonWebKey);
  689.                 return JwsUtils.getPublicKeySignatureVerifier(this.publicKey, algo);
  690.             }
  691.             else {
  692.                 throw this.newUtilsExceptionErrorKidUnavailable(true);
  693.             }
  694.         case PUBLIC_KEY:
  695.             this.publicKey = this.remoteStoreProvider.readPublicKey(this.kid, this.remoteStoreConfig);
  696.             if(this.publicKey==null) {
  697.                 throw this.newUtilsExceptionErrorKidUnavailable(true);
  698.             }
  699.             return JwsUtils.getPublicKeySignatureVerifier(this.publicKey, algo);
  700.         case X509:
  701.             org.openspcoop2.utils.certificate.Certificate certificate = this.remoteStoreProvider.readX509(this.kid, this.remoteStoreConfig);
  702.             if(certificate==null) {
  703.                 throw this.newUtilsExceptionErrorKidUnavailable(false);
  704.             }
  705.             this.x509Certificate = certificate.getCertificate().getCertificate();
  706.             return JwsUtils.getPublicKeySignatureVerifier(this.x509Certificate, algo);
  707.         default:
  708.             throw new UtilsException("RemoteStoreKeyType '"+this.remoteStoreKeyType+"' unknown");
  709.         }
  710.     }
  711.     private UtilsException newUtilsExceptionErrorKidUnavailable(boolean publicKey) {
  712.         String prefix = publicKey? "Public Key" : "Certificate";
  713.         return new UtilsException(prefix+" with kid '"+this.kid+"' unavailable");
  714.     }
  715. }
Created with JaCoCo 0.8.8.202204050719