MessageSecuritySender_wss4j.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.wss4j;


  25. import java.io.FileNotFoundException;
  26. import java.net.URISyntaxException;
  27. import java.util.ArrayList;
  28. import java.util.HashMap;
  29. import java.util.List;
  30. import java.util.Map;
  31. import java.util.Properties;

  33. import javax.security.auth.callback.CallbackHandler;
  34. import javax.xml.soap.SOAPMessage;

  36. import org.apache.cxf.binding.soap.SoapMessage;
  37. import org.apache.cxf.message.Attachment;
  38. import org.apache.cxf.message.Exchange;
  39. import org.apache.cxf.message.ExchangeImpl;
  40. import org.apache.cxf.message.MessageImpl;
  41. import org.apache.cxf.phase.PhaseInterceptor;
  42. import org.apache.cxf.ws.security.wss4j.WSS4JOutInterceptor;
  43. import org.apache.wss4j.common.ext.WSSecurityException;
  44. import org.apache.wss4j.dom.handler.WSHandlerConstants;
  45. import org.openspcoop2.message.MessageUtils;
  46. import org.openspcoop2.message.OpenSPCoop2Message;
  47. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  48. import org.openspcoop2.message.constants.Costanti;
  49. import org.openspcoop2.message.constants.MessageType;
  50. import org.openspcoop2.message.constants.ServiceBinding;
  51. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  52. import org.openspcoop2.security.SecurityException;
  53. import org.openspcoop2.security.keystore.KeystoreConstants;
  54. import org.openspcoop2.security.message.IMessageSecuritySender;
  55. import org.openspcoop2.security.message.MessageSecurityContext;
  56. import org.openspcoop2.security.message.constants.SecurityConstants;
  57. import org.openspcoop2.security.message.saml.SAMLBuilderConfig;
  58. import org.openspcoop2.security.message.saml.SAMLCallbackHandler;
  59. import org.openspcoop2.security.message.saml.SAMLUtilities;
  60. import org.openspcoop2.security.message.utils.AttachmentProcessingPart;
  61. import org.openspcoop2.security.message.utils.AttachmentsConfigReaderUtils;
  62. import org.openspcoop2.security.message.utils.EncryptionBean;
  63. import org.openspcoop2.security.message.utils.KeystoreUtils;
  64. import org.openspcoop2.security.message.utils.SignatureBean;
  65. import org.openspcoop2.utils.Utilities;
  66. import org.openspcoop2.utils.UtilsException;
  67. import org.openspcoop2.utils.id.IDUtilities;

  69. /**
  70.  * Classe per la gestione della WS-Security (WSDoAllSender).
  71.  *
  72.  * @author Lorenzo Nardi (nardi@link.it)
  73.  * @author Tommaso Burlon (tommaso.burlon@link.it)
  74.  * @author $Author$
  75.  * @version $Rev$, $Date$
  76.  */

  78. public class MessageSecuritySender_wss4j implements IMessageSecuritySender{

  80.     
  81.      @Override
  82.     public void process(MessageSecurityContext wssContext,OpenSPCoop2Message messageParam,org.openspcoop2.utils.Map<Object> ctx) throws SecurityException{
  83.         try{    
  84.             
  85.             if(ServiceBinding.SOAP.equals(messageParam.getServiceBinding())==false){
  86.                 throw new SecurityException("WSS4J Engine usable only with SOAP Binding");
  87.             }
  88.             OpenSPCoop2SoapMessage message = messageParam.castAsSoap();
  89.             
  90.             RequestInfo requestInfo = null;
  91.             if(ctx!=null && ctx.containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  92.                 requestInfo = (RequestInfo) ctx.get(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  93.             }
  94.             
  95.             
  96.             // ** Inizializzo handler CXF **/
  97.             
  98.             WSS4JOutInterceptor ohandler = new WSS4JOutInterceptor();
  99.             PhaseInterceptor<SoapMessage> handler = ohandler.createEndingInterceptor();
  100.             SoapMessage msgCtx = new SoapMessage(new MessageImpl());
  101.             msgCtx.setVersion(MessageType.SOAP_12.equals(message.getMessageType()) ? org.apache.cxf.binding.soap.Soap12.getInstance() : org.apache.cxf.binding.soap.Soap11.getInstance());
  102.             Exchange ex = new ExchangeImpl();
  103.             ex.setInMessage(msgCtx);
  104.             SOAPMessage soapMessage = MessageUtils.getSOAPMessage(message, false, message.getTransactionId());
  105.             msgCtx.setContent(SOAPMessage.class, soapMessage);
  106.             List<?> results = new ArrayList<>();
  107.             msgCtx.put(WSHandlerConstants.RECV_RESULTS, results);
  108.             
  109.             
  110.             // ** Localizzo attachments da trattare **/
  111.             
  112.             AttachmentProcessingPart app = AttachmentsConfigReaderUtils.getSecurityOnAttachments(wssContext);
  113.             
  114.             
  115.             // ** Imposto configurazione nel messaggio **/
  116.             // NOTA: farlo dopo getSecurityOnAttachments poichè si modifica la regola di quali attachments trattare.
  117.             
  118.             setOutgoingProperties(wssContext,msgCtx,messageParam,requestInfo,ctx);
  119.             
  120.             
  121.             // ** Registro attachments da trattare **/
  122.             
  123.             List<Attachment> listAttachments = null;
  124.             if(app!=null){
  125.                 listAttachments = org.openspcoop2.security.message.wss4j.WSSUtilities.readAttachments(app, message, msgCtx);
  126.                 if(listAttachments!=null && listAttachments.size()>0){
  127.                     msgCtx.setAttachments(listAttachments);
  128.                 }
  129.             }
  130.             
  131.             
  132.             // ** Applico sicurezza tramite CXF **/
  133.             
  134.             handler.handleMessage(msgCtx);
  135.             wssContext.getLog().debug("Print wssSender results...");
  136.             org.openspcoop2.security.message.wss4j.WSSUtilities.printWSResult(wssContext.getLog(), results);
  137.             
  138.             
  139.             // ** Riporto modifica degli attachments **/
  140.             
  141.             org.openspcoop2.security.message.wss4j.WSSUtilities.updateAttachments(listAttachments, message, msgCtx);
  142.                     
  143.         }
  144.         catch(Exception e){
  145.             
  146.             String msg = Utilities.getInnerNotEmptyMessageException(e).getMessage();
  147.             
  148.             Throwable innerExc = Utilities.getLastInnerException(e);
  149.             String innerMsg = null;
  150.             if(innerExc!=null){
  151.                 innerMsg = innerExc.getMessage();
  152.             }
  153.             
  154.             String messaggio = null;
  155.             if(msg!=null){
  156.                 messaggio = new String(msg);
  157.                 if(innerMsg!=null && !innerMsg.equals(msg)){
  158.                     messaggio = messaggio + " ; " + innerMsg;
  159.                 }
  160.             }
  161.             else{
  162.                 if(innerMsg!=null){
  163.                     messaggio = innerMsg;
  164.                 }
  165.             }
  166.             
  167.             // L'if scopre l'eventuale motivo preciso riguardo al fallimento della cifratura/firma.
  168.             if(Utilities.existsInnerException(e, WSSecurityException.class)){
  169.                 Throwable t = Utilities.getLastInnerException(e);
  170.                 if(t instanceof WSSecurityException){
  171.                     if(messaggio!=null){
  172.                         messaggio = messaggio + " ; " + t.getMessage();
  173.                     }
  174.                     else{
  175.                         messaggio = t.getMessage();
  176.                     }
  177.                 }
  178.             }
  179.             
  180.             SecurityException wssException = new SecurityException(messaggio, e);
  181.             wssException.setMsgErrore(messaggio);
  182.             throw wssException;
  183.         }
  184.         
  185.     }

  187.     private void setOutgoingProperties(MessageSecurityContext wssContext,SoapMessage msgCtx,OpenSPCoop2Message message, RequestInfo requestInfo,org.openspcoop2.utils.Map<Object> ctx) throws Exception{
  188.         boolean mustUnderstand = false;
  189.         boolean signatureUser = false;
  190.         boolean user = false;
  191.         Map<String,Object> wssOutgoingProperties = wssContext.getOutgoingProperties();
  192.         if (wssOutgoingProperties != null && wssOutgoingProperties.size() > 0) {
  193.             
  194.             // preprocess per SAML
  195.             SAMLUtilities.injectSignaturePropRefIdIntoSamlConfig(wssOutgoingProperties);
  196.             
  197.             // preprocess per multipropfile
  198.             preprocessMultipropFile(wssContext, msgCtx, wssOutgoingProperties, requestInfo, ctx);
  199.             
  200.             for (String key : wssOutgoingProperties.keySet()) {
  201.                 Object oValue = wssOutgoingProperties.get(key);
  202.                 String value = null;
  203.                 if(oValue!=null && oValue instanceof String) {
  204.                     value = (String) oValue;
  205.                 }
  206. //              if (SecurityConstants.ENCRYPTION_USER.equals(key) && SecurityConstants.USE_REQ_SIG_CERT.equals(value)) {
  207. //                  // value = ...;
  208. //              }
  209.                 
  210.                 // src/site/xdoc/migration/wss4j20.xml:the "samlPropFile" and "samlPropRefId" configuration tags have been removed. 
  211.                 // Per ottenere lo stesso effetto di poter utilizzare tale file di proprietà, si converta la proprietà nella nuova voce: 'samlCallbackRef'
  212.                 if(SecurityConstants.SAML_PROF_FILE.equals(key)){
  213.                     //System.out.println("CONVERT ["+key+"] ["+value+"] ...");
  214.                     SAMLBuilderConfig config = SAMLBuilderConfig.getSamlConfig(value, requestInfo);
  215.                     SAMLCallbackHandler samlCallbackHandler = new SAMLCallbackHandler(config);
  216.                     msgCtx.put(SecurityConstants.SAML_CALLBACK_REF, samlCallbackHandler);
  217.                 }
  218.                 else if(SecurityConstants.SAML_PROF_REF_ID.equals(key)){
  219.                     if(oValue!=null && oValue instanceof Properties) {
  220.                         Properties p = (Properties) oValue;
  221.                         SAMLBuilderConfig config = SAMLBuilderConfig.getSamlConfig(p, requestInfo);
  222.                         SAMLCallbackHandler samlCallbackHandler = new SAMLCallbackHandler(config);
  223.                         msgCtx.put(SecurityConstants.SAML_CALLBACK_REF, samlCallbackHandler);
  224.                     }
  225.                     else {
  226.                         throw new Exception("Property ["+key+"] with uncorrect type: "+(oValue!=null ? oValue.getClass().getName() : "value is null"));
  227.                     }
  228.                 }
  229.                 else if(SecurityConstants.ENCRYPTION_PARTS.equals(key) || SecurityConstants.SIGNATURE_PARTS.equals(key)){
  230.                     if(value!=null) {
  231.                         msgCtx.put(key, normalizeWss4jParts(value,message));
  232.                     }
  233.                 }
  234.                 else if(SecurityConstants.PASSWORD_CALLBACK_REF.equals(key)) {
  235.                     msgCtx.put(key, oValue);
  236.                 }
  237.                 else if(SecurityConstants.SIGNATURE_PROPERTY_REF_ID.equals(key) || 
  238.                         SecurityConstants.SIGNATURE_VERIFICATION_PROPERTY_REF_ID.equals(key) || 
  239.                         SecurityConstants.ENCRYPTION_PROPERTY_REF_ID.equals(key) || 
  240.                         SecurityConstants.DECRYPTION_PROPERTY_REF_ID.equals(key) ) {
  241.                     if(value!=null) {
  242.                         msgCtx.put(key, value);
  243.                     }
  244.                     else { 
  245.                         String id = key+"_"+IDUtilities.getUniqueSerialNumber("wssSecurity.setOutgoingProperties");
  246.                         msgCtx.put(key, id);
  247.                         msgCtx.put(id, oValue);
  248.                         if(oValue!=null && oValue instanceof Properties) {
  249.                             Properties p = (Properties) oValue;
  250.                             p.put(KeystoreConstants.PROPERTY_REQUEST_INFO, requestInfo);
  251.                         }
  252.                     }
  253.                 }
  254.                 else if(SecurityConstants.ENCRYPT_ACTION_OLD.equals(key)) {
  255.                     // backward compatibility per adeguamento costante rispetto a wss4j 2.3.x
  256.                     msgCtx.put(SecurityConstants.ENCRYPTION_ACTION, value);
  257.                 }
  258.                 else{
  259.                     msgCtx.put(key, value);
  260.                     if(SecurityConstants.MUST_UNDERSTAND.equals(key)){
  261.                         mustUnderstand = true;
  262.                     }
  263.                     else if(SecurityConstants.SIGNATURE_USER.equals(key)){
  264.                         signatureUser = true;
  265.                     }
  266.                     else if(SecurityConstants.USER.equals(key)){
  267.                         user = true;
  268.                     }
  269.                 }
  270.             }
  271.         }
  272.         if(!mustUnderstand){
  273.             //Il mustUnderstand non e' stato specificato. Lo imposto a false.
  274.             msgCtx.put(SecurityConstants.MUST_UNDERSTAND , SecurityConstants.FALSE);
  275.         }
  276.         if(wssContext.getActor()!=null){
  277.             msgCtx.put(SecurityConstants.ACTOR, wssContext.getActor());
  278.         }
  279.         if(signatureUser && !user) {
  280.             // fix: Caused by: org.apache.cxf.binding.soap.SoapFault: Empty username for specified action.
  281.             // at org.apache.cxf.ws.security.wss4j.WSS4JOutInterceptor$WSS4JOutInterceptorInternal.handleMessageInternal(WSS4JOutInterceptor.java:230) ~[cxf-rt-ws-security-3.2.6.jar:3.1.7]
  282.             //        at org.apache.cxf.ws.security.wss4j.WSS4JOutInterceptor$WSS4JOutInterceptorInternal.handleMessage(WSS4JOutInterceptor.java:135) ~[cxf-rt-ws-security-3.2.6.jar:3.1.7]
  283.             msgCtx.put(SecurityConstants.USER, (String) msgCtx.get(SecurityConstants.SIGNATURE_USER));
  284.         }
  285.     }
  286.     
  287.     private void preprocessMultipropFile(MessageSecurityContext wssContext,SoapMessage msgCtx,Map<String,Object> wssOutgoingProperties, RequestInfo requestInfo,org.openspcoop2.utils.Map<Object> ctx) throws FileNotFoundException, UtilsException, SecurityException, URISyntaxException {
  288.         
  289.         String forceSignatureUser = null;
  290.         String forceEncryptionUser = null;
  291.         
  292.         HashMap<String, String> mapAliasToPassword = new HashMap<>();
  293.         for (String key : wssOutgoingProperties.keySet()) {
  294.             if(SecurityConstants.SIGNATURE_MULTI_PROPERTY_FILE.equals(key)) {
  295.                 SignatureBean bean = KeystoreUtils.getSenderSignatureBean(wssContext, ctx);
  296.                 if(bean.getMultiKeystore()==null) {
  297.                     throw new SecurityException("Multiproperty config not exists");
  298.                 }
  299.                 String keyAlias = bean.getUser();
  300.                 String internalAlias = bean.getMultiKeystore().getInternalConfigAlias(keyAlias);
  301.                 Properties p = new Properties();
  302.                 p.put(KeystoreConstants.PROPERTY_KEYSTORE_PATH, bean.getMultiKeystore().getKeystorePath(internalAlias));
  303.                 p.put(KeystoreConstants.PROPERTY_KEYSTORE_PASSWORD, bean.getMultiKeystore().getKeystorePassword(internalAlias));
  304.                 p.put(KeystoreConstants.PROPERTY_KEYSTORE_TYPE, bean.getMultiKeystore().getKeystoreType(internalAlias));
  305.                 p.put(KeystoreConstants.PROPERTY_PROVIDER, KeystoreConstants.PROVIDER_GOVWAY);
  306.                 p.put(KeystoreConstants.PROPERTY_REQUEST_INFO, requestInfo);
  307.                 String id = SecurityConstants.SIGNATURE_PROPERTY_REF_ID+"_"+IDUtilities.getUniqueSerialNumber("wssSecurity.setOutgoingProperties");
  308.                 msgCtx.put(SecurityConstants.SIGNATURE_PROPERTY_REF_ID, id);
  309.                 msgCtx.put(id, p);
  310.                 
  311.                 String password = bean.getPassword();
  312.                 msgCtx.put(SecurityConstants.SIGNATURE_PASSWORD, bean.getPassword());
  313.                 mapAliasToPassword.put(keyAlias, password);

  315.                 forceSignatureUser = keyAlias;
  316.             }
  317.             else if(SecurityConstants.ENCRYPTION_MULTI_PROPERTY_FILE.equals(key)) {
  318.                 EncryptionBean bean = KeystoreUtils.getSenderEncryptionBean(wssContext, ctx);
  319.                 if(bean.getMultiKeystore()==null) {
  320.                     throw new SecurityException("Multiproperty config not exists");
  321.                 }
  322.                 String keyAlias = bean.getUser();
  323.                 String internalAlias = bean.getMultiKeystore().getInternalConfigAlias(keyAlias);
  324.                 Properties p = new Properties();
  325.                 p.put(KeystoreConstants.PROPERTY_KEYSTORE_PATH, bean.getMultiKeystore().getKeystorePath(internalAlias));
  326.                 p.put(KeystoreConstants.PROPERTY_KEYSTORE_PASSWORD, bean.getMultiKeystore().getKeystorePassword(internalAlias));
  327.                 p.put(KeystoreConstants.PROPERTY_KEYSTORE_TYPE, bean.getMultiKeystore().getKeystoreType(internalAlias));
  328.                 p.put(KeystoreConstants.PROPERTY_PROVIDER, KeystoreConstants.PROVIDER_GOVWAY);
  329.                 p.put(KeystoreConstants.PROPERTY_REQUEST_INFO, requestInfo);
  330.                 String id = SecurityConstants.ENCRYPTION_PROPERTY_REF_ID +"_"+IDUtilities.getUniqueSerialNumber("wssSecurity.setOutgoingProperties");
  331.                 msgCtx.put(SecurityConstants.ENCRYPTION_PROPERTY_REF_ID , id);
  332.                 msgCtx.put(id, p);
  333.                 
  334.                 String password = bean.getPassword();
  335.                 mapAliasToPassword.put(keyAlias, password);

  337.                 forceEncryptionUser = keyAlias;
  338.             }
  339.         }
  340.         
  341.         if (!mapAliasToPassword.isEmpty()) {
  342.             CallbackHandler pwCallbackHandler = MessageSecurityContext.newCallbackHandler(mapAliasToPassword);
  343.             msgCtx.put(SecurityConstants.PASSWORD_CALLBACK_REF, pwCallbackHandler);
  344.         }

  346.         if(forceSignatureUser!=null) {
  347.             wssOutgoingProperties.remove(SecurityConstants.SIGNATURE_USER);
  348.             wssOutgoingProperties.put(SecurityConstants.SIGNATURE_USER, forceSignatureUser);
  349.         }
  350.         if(forceEncryptionUser!=null) {
  351.             wssOutgoingProperties.remove(SecurityConstants.ENCRYPTION_USER);
  352.             wssOutgoingProperties.put(SecurityConstants.ENCRYPTION_USER, forceEncryptionUser);
  353.         }
  354.     }
  355.     
  356.     private String normalizeWss4jParts(String parts,OpenSPCoop2Message message){
  357.         StringBuilder bf = new StringBuilder();
  358.         String[]split = ((String)parts).split(";");
  359.         for (int i = 0; i < split.length; i++) {
  360.             if(i>0){
  361.                 bf.append(";");
  362.             }
  363.             String n = split[i].trim();
  364.             if(n.contains("{"+SecurityConstants.NAMESPACE_ATTACH+"}")){
  365.                 if(n.startsWith("{"+SecurityConstants.PART_ELEMENT+"}")){
  366.                     bf.append("{"+SecurityConstants.PART_ELEMENT+"}"+SecurityConstants.CID_ATTACH_WSS4J);
  367.                 }
  368.                 else {
  369.                     bf.append("{"+SecurityConstants.PART_CONTENT+"}"+SecurityConstants.CID_ATTACH_WSS4J);
  370.                 }
  371.             }
  372.             else{
  373.                 bf.append(n);
  374.             }
  375.         }
  376.         //System.out.println("PRIMA ["+parts+"] DOPO ["+bf.toString()+"]");
  377.         
  378.         String newParts = bf.toString();
  379.         
  380.         while(newParts.contains(SecurityConstants.SOAP_NAMESPACE_TEMPLATE)) {
  381.             String namespace = MessageType.SOAP_11.equals(message.getMessageType()) ? Costanti.SOAP_ENVELOPE_NAMESPACE : Costanti.SOAP12_ENVELOPE_NAMESPACE;
  382.             newParts = newParts.replace(SecurityConstants.SOAP_NAMESPACE_TEMPLATE, namespace);
  383.         }
  384.         
  385.         return newParts;
  386.     }
  387.  
  388. }




Created with JaCoCo 0.8.8.202204050719