MessageSecuritySender_jose.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */


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


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

  28. import org.openspcoop2.core.commons.DBUtils;
  29. import org.openspcoop2.core.constants.Costanti;
  30. import org.openspcoop2.generic_project.exception.NotFoundException;
  31. import org.openspcoop2.message.OpenSPCoop2Message;
  32. import org.openspcoop2.message.OpenSPCoop2RestJsonMessage;
  33. import org.openspcoop2.message.constants.MessageType;
  34. import org.openspcoop2.message.constants.ServiceBinding;
  35. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  36. import org.openspcoop2.security.SecurityException;
  37. import org.openspcoop2.security.message.AbstractRESTMessageSecuritySender;
  38. import org.openspcoop2.security.message.MessageSecurityContext;
  39. import org.openspcoop2.security.message.constants.SecurityConstants;
  40. import org.openspcoop2.security.message.utils.EncryptionBean;
  41. import org.openspcoop2.security.message.utils.KeystoreUtils;
  42. import org.openspcoop2.security.message.utils.PropertiesUtils;
  43. import org.openspcoop2.security.message.utils.SignatureBean;
  44. import org.openspcoop2.utils.Utilities;
  45. import org.openspcoop2.utils.certificate.JWKSet;
  46. import org.openspcoop2.utils.certificate.KeyStore;
  47. import org.openspcoop2.utils.certificate.KeystoreType;
  48. import org.openspcoop2.utils.security.JOSESerialization;
  49. import org.openspcoop2.utils.security.JWEOptions;
  50. import org.openspcoop2.utils.security.JWSOptions;
  51. import org.openspcoop2.utils.security.JsonEncrypt;
  52. import org.openspcoop2.utils.security.JsonSignature;
  53. import org.openspcoop2.utils.security.JwtHeaders;

  55. /**
  56.  * MessageSecuritySender_jose
  57.  *
  58.  * @author Andrea Poli (apoli@link.it)
  59.  * @author $Author$
  60.  * @version $Rev$, $Date$
  61.  */

  63. public class MessageSecuritySender_jose extends AbstractRESTMessageSecuritySender{

  65.     
  66.      @Override
  67.     public void process(MessageSecurityContext messageSecurityContext,OpenSPCoop2Message messageParam, org.openspcoop2.utils.Map<Object> ctx) throws SecurityException{
  68.         try{    
  69.             
  70.             if(ServiceBinding.REST.equals(messageParam.getServiceBinding())==false){
  71.                 throw new SecurityException(JOSECostanti.JOSE_ENGINE_DESCRIPTION+" usable only with REST Binding");
  72.             }
  73.             if(MessageType.JSON.equals(messageParam.getMessageType())==false) {
  74.                 throw new SecurityException(JOSECostanti.JOSE_ENGINE_DESCRIPTION+" usable only with REST Binding and a json message, found: "+messageParam.getMessageType());
  75.             }
  76.             OpenSPCoop2RestJsonMessage restJsonMessage = messageParam.castAsRestJson();
  77.             
  78.             RequestInfo requestInfo = null;
  79.             if(ctx!=null && ctx.containsKey(Costanti.REQUEST_INFO)) {
  80.                 requestInfo = (RequestInfo) ctx.get(Costanti.REQUEST_INFO);
  81.             }
  82.             
  83.             
  84.             
  85.             // ********** Leggo operazioni ***************
  86.             boolean encrypt = false;
  87.             boolean signature = false;

  89.             String[]actions = ((String)messageSecurityContext.getOutgoingProperties().get(SecurityConstants.ACTION)).split(" ");
  90.             for (int i = 0; i < actions.length; i++) {
  91.                 if(SecurityConstants.isActionEncryption(actions[i].trim())){
  92.                     encrypt = true;
  93.                 }
  94.                 else if(SecurityConstants.SIGNATURE_ACTION.equals(actions[i].trim())){
  95.                     signature = true;
  96.                 }
  97.                 else {
  98.                     throw new SecurityException(JOSECostanti.JOSE_ENGINE_DESCRIPTION+"; action '"+actions[i]+"' unsupported");
  99.                 }
  100.             }
  101.             
  102.             if(encrypt && signature) {
  103.                 throw new SecurityException(JOSECostanti.JOSE_ENGINE_DESCRIPTION+" usable only with one function beetwen encrypt or signature");
  104.             }
  105.             if(!encrypt && !signature) {
  106.                 throw new SecurityException(JOSECostanti.JOSE_ENGINE_DESCRIPTION+" require one function beetwen encrypt or signature");
  107.             }
  108.             

  110.             
  111.             
  112.             if(signature) {
  113.                 
  114.                 
  115.                 // **************** Leggo parametri signature store **************************

  117.                 JOSESerialization joseSerialization = null;
  118.                 String mode = (String) messageSecurityContext.getOutgoingProperties().get(SecurityConstants.SIGNATURE_MODE);
  119.                 if(mode==null || "".equals(mode.trim())){
  120.                     throw new SecurityException(JOSECostanti.JOSE_ENGINE_SIGNATURE_DESCRIPTION+" require '"+SecurityConstants.SIGNATURE_MODE+"' property");
  121.                 }
  122.                 try {
  123.                     joseSerialization = JOSEUtils.toJOSESerialization(mode);
  124.                 }catch(Exception e) {
  125.                     throw new SecurityException(JOSECostanti.JOSE_ENGINE_SIGNATURE_DESCRIPTION+", '"+SecurityConstants.SIGNATURE_MODE+"' property error: "+e.getMessage(),e);
  126.                 }
  127.                 JWSOptions jwsOptions = new JWSOptions(joseSerialization);
  128.                 
  129.                 String signatureDetachedParam = (String) messageSecurityContext.getOutgoingProperties().get(SecurityConstants.SIGNATURE_DETACHED);
  130.                 if(signatureDetachedParam!=null) {
  131.                     jwsOptions.setDetached(SecurityConstants.SIGNATURE_DETACHED_TRUE.equalsIgnoreCase(signatureDetachedParam));
  132.                 }
  133.                 
  134.                 String signaturePayloadEncodingParam = (String) messageSecurityContext.getOutgoingProperties().get(SecurityConstants.SIGNATURE_PAYLOAD_ENCODING);
  135.                 if(signaturePayloadEncodingParam!=null) {
  136.                     jwsOptions.setPayloadEncoding(SecurityConstants.SIGNATURE_PAYLOAD_ENCODING_TRUE.equalsIgnoreCase(signaturePayloadEncodingParam));
  137.                 }
  138.                                 
  139.                 JsonSignature jsonSignature = null;
  140.                 SignatureBean bean = null;
  141.                 NotFoundException notFound = null;
  142.                 try {
  143.                     bean = PropertiesUtils.getSenderSignatureBean(messageSecurityContext);
  144.                 }catch(NotFoundException e) {
  145.                     notFound = e;
  146.                 }
  147.                 if(bean!=null) {
  148.                     Properties signatureProperties = bean.getProperties();
  149.                     boolean throwError = true;
  150.                     Map<String,Object> dynamicMap = Costanti.readDynamicMap(ctx);
  151.                     JOSEUtils.injectKeystore(requestInfo, dynamicMap, signatureProperties, messageSecurityContext.getLog(), throwError); // serve per leggere il keystore dalla cache
  152.                     JwtHeaders jwtHeaders = JOSEUtils.getJwtHeaders(messageSecurityContext.getOutgoingProperties(), messageParam); // la configurazione per kid, jwk e x5c viene configurata via properties
  153.                     jsonSignature = new JsonSignature(signatureProperties, jwtHeaders, jwsOptions); 
  154.                 }
  155.                 else {  
  156.                     KeyStore signatureKS = null;
  157.                     //KeyStore signatureTrustStoreKS = null;
  158.                     JWKSet signatureJWKSet = null;
  159.                     String aliasSignatureUser = null;
  160.                     String aliasSignaturePassword = null;
  161.                     try {
  162.                         bean = KeystoreUtils.getSenderSignatureBean(messageSecurityContext, ctx);
  163.                     }catch(Exception e) {
  164.                         // Lancio come messaggio eccezione precedente
  165.                         if(notFound!=null) {
  166.                             messageSecurityContext.getLog().error(e.getMessage(),e);
  167.                             throw notFound;
  168.                         }
  169.                         else {
  170.                             throw e;
  171.                         }
  172.                     }
  173.                     
  174.                     signatureKS = bean.getKeystore();
  175.                     //signatureTrustStoreKS = bean.getTruststore();
  176.                     signatureJWKSet = bean.getJwkSet();
  177.                     aliasSignatureUser = bean.getUser();
  178.                     aliasSignaturePassword = bean.getPassword();

  180.                     if(signatureKS==null && signatureJWKSet==null) {
  181.                         throw new SecurityException(JOSECostanti.JOSE_ENGINE_SIGNATURE_DESCRIPTION+" require keystore");
  182.                     }
  183.                     if(aliasSignatureUser==null) {
  184.                         throw new SecurityException(JOSECostanti.JOSE_ENGINE_SIGNATURE_DESCRIPTION+" require alias private key");
  185.                     }
  186.                     if(signatureKS!=null && aliasSignaturePassword==null) {
  187.                         boolean required = true;
  188.                         if(KeystoreType.JKS.isType(signatureKS.getKeystoreType())) {
  189.                             required = DBUtils.isKeystoreJksKeyPasswordRequired();
  190.                         }
  191.                         else if(KeystoreType.PKCS12.isType(signatureKS.getKeystoreType())) {
  192.                             required = DBUtils.isKeystorePkcs12KeyPasswordRequired();
  193.                         }
  194.                         if(required) {
  195.                             throw new SecurityException(JOSECostanti.JOSE_ENGINE_SIGNATURE_DESCRIPTION+" require password private key");
  196.                         }
  197.                     }
  198.                     
  199.                     String signatureAlgorithm = (String) messageSecurityContext.getOutgoingProperties().get(SecurityConstants.SIGNATURE_ALGORITHM);
  200.                     if(signatureAlgorithm==null || "".equals(signatureAlgorithm.trim())){
  201.                         throw new SecurityException(JOSECostanti.JOSE_ENGINE_SIGNATURE_DESCRIPTION+" require '"+SecurityConstants.SIGNATURE_ALGORITHM+"' property");
  202.                     }
  203.                     
  204.                     String symmetricKeyParam = (String) messageSecurityContext.getOutgoingProperties().get(SecurityConstants.SYMMETRIC_KEY);
  205.                     boolean symmetricKey = false;
  206.                     if(symmetricKeyParam!=null) {
  207.                         symmetricKey = SecurityConstants.SYMMETRIC_KEY_TRUE.equalsIgnoreCase(symmetricKeyParam);
  208.                     }
  209.                     
  210.                     if(signatureKS!=null) {
  211.                         JwtHeaders jwtHeaders = JOSEUtils.getJwtHeaders(messageSecurityContext.getOutgoingProperties(), messageParam, aliasSignatureUser, signatureKS);
  212.                         jsonSignature = new JsonSignature(signatureKS, symmetricKey, aliasSignatureUser, aliasSignaturePassword, signatureAlgorithm, jwtHeaders, jwsOptions);   
  213.                     }
  214.                     else {
  215.                         JwtHeaders jwtHeaders = JOSEUtils.getJwtHeaders(messageSecurityContext.getOutgoingProperties(), messageParam, aliasSignatureUser, signatureJWKSet);
  216.                         jsonSignature = new JsonSignature(signatureJWKSet.getJsonWebKeys(), symmetricKey, aliasSignatureUser, signatureAlgorithm, jwtHeaders, jwsOptions);  
  217.                     }
  218.                 }
  219.                 

  221.                 
  222.                 
  223.                 
  224.                 
  225.                 // **************** Process **************************
  226.                 
  227.                 String contentSign = jsonSignature.sign(restJsonMessage.getContent());
  228.                 if(jwsOptions.isDetached()) {
  229.                     this.setDetachedSignatureInMessage(messageSecurityContext.getOutgoingProperties(), 
  230.                             restJsonMessage, 
  231.                             JOSECostanti.JOSE_ENGINE_SIGNATURE_DESCRIPTION, 
  232.                             contentSign);
  233.                 }else {
  234.                     restJsonMessage.updateContent(contentSign);
  235.                 }
  236.                 
  237.                 
  238.                 
  239.             } // fine signature
  240.             
  241.             
  242.             
  243.             
  244.             
  245.             else if(encrypt){
  246.             
  247.                 // **************** Leggo parametri encryption store **************************
  248.                 
  249.                 JOSESerialization joseSerialization = null;
  250.                 String mode = (String) messageSecurityContext.getOutgoingProperties().get(SecurityConstants.ENCRYPTION_MODE);
  251.                 if(mode==null || "".equals(mode.trim())){
  252.                     throw new SecurityException(JOSECostanti.JOSE_ENGINE_ENCRYPT_DESCRIPTION+" require '"+SecurityConstants.ENCRYPTION_MODE+"' property");
  253.                 }
  254.                 try {
  255.                     joseSerialization = JOSEUtils.toJOSESerialization(mode);
  256.                 }catch(Exception e) {
  257.                     throw new SecurityException(JOSECostanti.JOSE_ENGINE_ENCRYPT_DESCRIPTION+", '"+SecurityConstants.ENCRYPTION_MODE+"' property error: "+e.getMessage(),e);
  258.                 }
  259.                 JWEOptions jweOptions = new JWEOptions(joseSerialization);
  260.                 
  261.                 String encryptionDeflateParam = (String) messageSecurityContext.getOutgoingProperties().get(SecurityConstants.ENCRYPTION_DEFLATE);
  262.                 if(encryptionDeflateParam!=null) {
  263.                     jweOptions.setDeflate(SecurityConstants.ENCRYPTION_DEFLATE_TRUE.equalsIgnoreCase(encryptionDeflateParam));
  264.                 }
  265.                 
  266.                 JsonEncrypt jsonEncrypt = null;
  267.                 EncryptionBean bean = null;
  268.                 NotFoundException notFound = null;
  269.                 try {
  270.                     bean = PropertiesUtils.getSenderEncryptionBean(messageSecurityContext);
  271.                 }catch(NotFoundException e) {
  272.                     notFound = e;
  273.                 }
  274.                 if(bean!=null) {
  275.                     Properties encryptionProperties = bean.getProperties();
  276.                     boolean throwError = true;
  277.                     Map<String,Object> dynamicMap = Costanti.readDynamicMap(ctx);
  278.                     JOSEUtils.injectKeystore(requestInfo, dynamicMap, encryptionProperties, messageSecurityContext.getLog(), throwError); // serve per leggere il keystore dalla cache
  279.                     JwtHeaders jwtHeaders = JOSEUtils.getJwtHeaders(messageSecurityContext.getOutgoingProperties(), messageParam); // la configurazione per kid, jwk e x5c viene configurata via properties
  280.                     jsonEncrypt = new JsonEncrypt(encryptionProperties, jwtHeaders, jweOptions); 
  281.                 }
  282.                 else {  
  283.                     KeyStore encryptionKS = null;
  284.                     KeyStore encryptionTrustStoreKS = null;
  285.                     boolean encryptionSymmetric = false;
  286.                     JWKSet encryptionJWKSet = null;
  287.                     String aliasEncryptUser = null;
  288.                     String aliasEncryptPassword = null;
  289.                     try {
  290.                         bean = KeystoreUtils.getSenderEncryptionBean(messageSecurityContext, ctx);
  291.                     }catch(Exception e) {
  292.                         // Lancio come messaggio eccezione precedente
  293.                         if(notFound!=null) {
  294.                             messageSecurityContext.getLog().error(e.getMessage(),e);
  295.                             throw notFound;
  296.                         }
  297.                         else {
  298.                             throw e;
  299.                         }
  300.                     }
  301.                     
  302.                     encryptionKS = bean.getKeystore();
  303.                     encryptionTrustStoreKS = bean.getTruststore();
  304.                     encryptionSymmetric = bean.isEncryptionSimmetric();
  305.                     encryptionJWKSet = bean.getJwkSet();
  306.                     aliasEncryptUser = bean.getUser();
  307.                     aliasEncryptPassword = bean.getPassword();

  309.                     if(encryptionSymmetric) {
  310.                         if(encryptionKS==null) {
  311.                             throw new SecurityException(JOSECostanti.JOSE_ENGINE_ENCRYPT_DESCRIPTION+" require keystore");
  312.                         }
  313.                         if(aliasEncryptUser==null) {
  314.                             throw new SecurityException(JOSECostanti.JOSE_ENGINE_ENCRYPT_DESCRIPTION+" require alias secret key");
  315.                         }
  316.                         if(aliasEncryptPassword==null) {
  317.                             throw new SecurityException(JOSECostanti.JOSE_ENGINE_ENCRYPT_DESCRIPTION+" require password secret key");
  318.                         }
  319.                     }
  320.                     else {
  321.                         if(encryptionTrustStoreKS==null && encryptionJWKSet==null) {
  322.                             throw new SecurityException(JOSECostanti.JOSE_ENGINE_ENCRYPT_DESCRIPTION+" require truststore");
  323.                         }
  324.                         if(aliasEncryptUser==null) {
  325.                             throw new SecurityException(JOSECostanti.JOSE_ENGINE_ENCRYPT_DESCRIPTION+" require alias public key");
  326.                         }
  327.                     }

  329.                     
  330.                     String encryptionKeyAlgorithm = (String) messageSecurityContext.getOutgoingProperties().get(SecurityConstants.ENCRYPTION_KEY_ALGORITHM);
  331.                     if(encryptionKeyAlgorithm==null || "".equals(encryptionKeyAlgorithm.trim())){
  332.                         throw new SecurityException(JOSECostanti.JOSE_ENGINE_ENCRYPT_DESCRIPTION+" require '"+SecurityConstants.ENCRYPTION_KEY_ALGORITHM+"' property");
  333.                     }
  334.                     
  335.                     String encryptionContentAlgorithm = (String) messageSecurityContext.getOutgoingProperties().get(SecurityConstants.ENCRYPTION_CONTENT_ALGORITHM);
  336.                     if(encryptionContentAlgorithm==null || "".equals(encryptionContentAlgorithm.trim())){
  337.                         throw new SecurityException(JOSECostanti.JOSE_ENGINE_ENCRYPT_DESCRIPTION+" require '"+SecurityConstants.ENCRYPTION_CONTENT_ALGORITHM+"' property");
  338.                     }

  340.                     if(encryptionSymmetric) {
  341.                         JwtHeaders jwtHeaders = JOSEUtils.getJwtHeaders(messageSecurityContext.getOutgoingProperties(), messageParam, aliasEncryptUser);
  342.                         jsonEncrypt = new JsonEncrypt(encryptionKS, aliasEncryptUser, aliasEncryptPassword, encryptionKeyAlgorithm, encryptionContentAlgorithm,  jwtHeaders, jweOptions);
  343.                     }else {
  344.                         if(encryptionTrustStoreKS!=null) {
  345.                             JwtHeaders jwtHeaders = JOSEUtils.getJwtHeaders(messageSecurityContext.getOutgoingProperties(), messageParam, aliasEncryptUser, encryptionTrustStoreKS);
  346.                             jsonEncrypt = new JsonEncrypt(encryptionTrustStoreKS, aliasEncryptUser, encryptionKeyAlgorithm, encryptionContentAlgorithm, jwtHeaders, jweOptions);
  347.                         }
  348.                         else {
  349.                             JwtHeaders jwtHeaders = JOSEUtils.getJwtHeaders(messageSecurityContext.getOutgoingProperties(), messageParam, aliasEncryptUser, encryptionJWKSet);
  350.                             jsonEncrypt = new JsonEncrypt(encryptionJWKSet.getJsonWebKeys(), encryptionSymmetric, aliasEncryptUser, encryptionKeyAlgorithm, encryptionContentAlgorithm, jwtHeaders, jweOptions);
  351.                         }
  352.                     }
  353.                 }
  354.         

  356.                 
  357.                 
  358.                 // **************** Process **************************
  359.                 
  360.                 String contentEncrypted = jsonEncrypt.encrypt(restJsonMessage.getContent());
  361.                 restJsonMessage.updateContent(contentEncrypted);
  362.                 

  364.             } // fine encrypt


  367.         }
  368.         catch(Exception e){
  369.             
  370.             String msg = Utilities.getInnerNotEmptyMessageException(e).getMessage();
  371.             
  372.             Throwable innerExc = Utilities.getLastInnerException(e);
  373.             String innerMsg = null;
  374.             if(innerExc!=null){
  375.                 innerMsg = innerExc.getMessage();
  376.             }
  377.             
  378.             String messaggio = null;
  379.             if(msg!=null){
  380.                 messaggio = new String(msg);
  381.                 if(innerMsg!=null && !innerMsg.equals(msg)){
  382.                     messaggio = messaggio + " ; " + innerMsg;
  383.                 }
  384.             }
  385.             else{
  386.                 if(innerMsg!=null){
  387.                     messaggio = innerMsg;
  388.                 }
  389.             }
  390.             
  391.             SecurityException wssException = new SecurityException(e.getMessage(), e);
  392.             wssException.setMsgErrore(messaggio);
  393.             throw wssException;
  394.         }
  395.         
  396.     }

  398.  
  399. }




Created with JaCoCo 0.8.8.202204050719