MessageSecurityReceiver_soapbox.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.soapbox;

  24. import java.io.ByteArrayOutputStream;
  25. import java.io.PrintStream;
  26. import java.security.PublicKey;
  27. import java.security.cert.X509Certificate;
  28. import java.util.ArrayList;
  29. import java.util.HashMap;
  30. import java.util.Iterator;
  31. import java.util.List;
  32. import java.util.Map;

  34. import javax.xml.namespace.QName;
  35. import javax.xml.soap.AttachmentPart;
  36. import javax.xml.soap.SOAPException;
  37. import javax.xml.soap.SOAPPart;

  39. import org.adroitlogic.soapbox.MessageSecurityContext;
  40. import org.adroitlogic.ultraesb.core.MessageImpl;
  41. import org.openspcoop2.message.OpenSPCoop2Message;
  42. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  43. import org.openspcoop2.message.constants.ServiceBinding;
  44. import org.openspcoop2.message.exception.MessageException;
  45. import org.openspcoop2.message.exception.MessageNotSupportedException;
  46. import org.openspcoop2.message.soap.reference.Reference;
  47. import org.openspcoop2.protocol.sdk.Busta;
  48. import org.openspcoop2.protocol.sdk.constants.CodiceErroreCooperazione;
  49. import org.openspcoop2.security.SecurityException;
  50. import org.openspcoop2.security.message.AbstractSOAPMessageSecurityReceiver;
  51. import org.openspcoop2.security.message.SubErrorCodeSecurity;
  52. import org.openspcoop2.security.message.constants.SecurityConstants;
  53. import org.openspcoop2.security.message.engine.MessageUtilities;
  54. import org.openspcoop2.security.message.engine.WSSUtilities;
  55. import org.openspcoop2.security.message.utils.EncryptionBean;
  56. import org.openspcoop2.security.message.utils.KeystoreUtils;
  57. import org.openspcoop2.security.message.utils.SignatureBean;
  58. import org.openspcoop2.utils.Utilities;
  59. import org.openspcoop2.utils.certificate.KeyStore;
  60. import org.openspcoop2.utils.resources.ClassLoaderUtilities;
  61. import org.w3c.dom.Document;



  65. /**
  66.  * WSSContext_soapbox
  67.  *
  68.  * @author Andrea Poli (apoli@link.it)
  69.  * @author Giovanni Bussu (bussu@link.it)
  70.  * @author $Author$
  71.  * @version $Rev$, $Date$
  72.  */
  73. public class MessageSecurityReceiver_soapbox extends AbstractSOAPMessageSecurityReceiver{

  75.     private X509Certificate [] certificates = null;
  76.     

  78.     @Override
  79.     public void process(org.openspcoop2.security.message.MessageSecurityContext messageSecurityContext,OpenSPCoop2Message messageParam,Busta busta,org.openspcoop2.utils.Map<Object> ctx) throws SecurityException{
  80.         try{
  81.             
  82.             if(ServiceBinding.SOAP.equals(messageParam.getServiceBinding())==false){
  83.                 throw new SecurityException("SoapBox Engine usable only with SOAP Binding");
  84.             }
  85.             OpenSPCoop2SoapMessage message = messageParam.castAsSoap();
  86.             
  87.             
  88.             
  89.             // ********** Leggo operazioni ***************
  90.             boolean decrypt = false;
  91.             boolean signature = false;
  92.             boolean timestamp = false;

  94.             String[]actions = ((String)messageSecurityContext.getIncomingProperties().get(SecurityConstants.ACTION)).split(" ");
  95.             for (int i = 0; i < actions.length; i++) {
  96.                 if(SecurityConstants.isActionEncryption(actions[i].trim())){
  97.                     decrypt = true;
  98.                 }
  99.                 else if(SecurityConstants.SIGNATURE_ACTION.equals(actions[i].trim())){
  100.                     signature = true;
  101.                 }
  102.                 else if(SecurityConstants.TIMESTAMP_ACTION.equals(actions[i].trim())){
  103.                     timestamp = true;
  104.                 }
  105.             }
  106.             // rilasciato vincolo di abilitazione signature o encryption per abilitare il timestamp
  107. //          if(!signature && !decrypt && timestamp){
  108. //              throw new WSSException("La funzionalita' "+WSSConstants.TIMESTAMP_ACTION+" richiede per essere abilitata almeno una delle seguenti altre funzionalita': "+
  109. //                      WSSConstants.ENCRYPT_ACTION+","+WSSConstants.SIGNATURE_ACTION);
  110. //          }
  111.             
  112.             
  113.             
  114.             
  115.             // ********** Inizializzo Header WSS ***************

  117.             SOAPPart sp = message.getSOAPPart();
  118.             //Document d = sp;
  119.             Document d = sp.getDocumentElement().getOwnerDocument();
  120.             Object mustUnderstandObject = messageSecurityContext.getIncomingProperties().get(SecurityConstants.MUST_UNDERSTAND);
  121.             boolean mustUnderstand = false;
  122.             if(mustUnderstandObject!=null){
  123.                 mustUnderstand = SecurityConstants.TRUE.equals(mustUnderstandObject);
  124.             }
  125.             MessageSecurityContext msgSecCtx = new MessageSecurityContext(d, new MessageImpl(true, null, "http"));
  126.             Iterator<?> it = message.getAttachments();
  127.             if(it!=null){
  128.                 while(it.hasNext()) {
  129.                     AttachmentPart part = (AttachmentPart) it.next();
  130.                     String contentId = part.getContentId();
  131.                     if(contentId.startsWith("<"))
  132.                         contentId = contentId.substring(1);
  133.                     if(contentId.endsWith(">"))
  134.                         contentId = contentId.substring(0,contentId.length()-1);
  135.                     msgSecCtx.setProperty(contentId, part); //tolgo < e > dal nome eventualmente
  136.                 }
  137.             }
  138.             
  139.             
  140.             
  141.             
  142.             
  143.             
  144.             // **************** Inizializzo process per validare timestamp **************************
  145.             
  146.             ProcessTimestampedMessage verifyTimestampedProc = null;
  147.             if(timestamp){
  148.                 verifyTimestampedProc = new ProcessTimestampedMessage();
  149.                 
  150.                 //future time to live
  151.                 Object futureTtlObject = messageSecurityContext.getIncomingProperties().get(SecurityConstants.TIMESTAMP_FUTURE_TTL);
  152.                 if(futureTtlObject==null){
  153.                     futureTtlObject = SecurityConstants.TIMESTAMP_SOAPBOX_FUTURE_TTL_DEFAULT;
  154.                 }
  155.                 String ttl = (String) futureTtlObject; 
  156.                 long futureTtlLong = -1;
  157.                 try{
  158.                     futureTtlLong = Long.parseLong(ttl);
  159.                 }catch(Exception e){
  160.                     throw new Exception("Indicazione "+SecurityConstants.TIMESTAMP_FUTURE_TTL+" non corretta: "+e.getMessage());
  161.                 }

  163.                 msgSecCtx.setProperty(SecurityConstants.TIMESTAMP_FUTURE_TTL, futureTtlLong * 1000l);

  165.                 //strict Timestamp handling
  166.                 Object strictObject = messageSecurityContext.getIncomingProperties().get(SecurityConstants.TIMESTAMP_STRICT);
  167.                 if(strictObject==null){
  168.                     strictObject = SecurityConstants.TRUE;
  169.                 }
  170.                 String strict = (String) strictObject; 
  171.                 boolean strictBoolean = false;
  172.                 try{
  173.                     strictBoolean = Boolean.parseBoolean(strict);
  174.                 }catch(Exception e){
  175.                     throw new Exception("Indicazione "+SecurityConstants.TIMESTAMP_STRICT+" non corretta: "+e.getMessage());
  176.                 }

  178.                 msgSecCtx.setProperty(SecurityConstants.TIMESTAMP_STRICT, strictBoolean);
  179.             }
  180.             
  181.             
  182.             
  183.             
  184.             
  185.             
  186.             // **************** Inizializzo process per decifrare **************************

  188.             ProcessPartialEncryptedMessage decryptMsgProc = null;
  189.             if(decrypt){
  190.                 decryptMsgProc = (ProcessPartialEncryptedMessage) ClassLoaderUtilities.newInstance(message.getProcessPartialEncryptedMessageClass());
  191.                 decryptMsgProc.setMessage(message);
  192.                 decryptMsgProc.setActor(messageSecurityContext.getActor());
  193.                 decryptMsgProc.setMustUnderstand(mustUnderstand);
  194.             }
  195.             
  196.             
  197.             
  198.             
  199.             
  200.             
  201.             
  202.             // **************** Inizializzo process per validare la firma **************************
  203.             
  204.             ProcessSignedMessage signMsgProc = null;
  205.             if(signature){
  206.                 signMsgProc = new ProcessSignedMessage();
  207.                 signMsgProc.setMessage(message);
  208.                 signMsgProc.setActor(messageSecurityContext.getActor());
  209.                 signMsgProc.setMustUnderstand(mustUnderstand);
  210.             }
  211.             
  212.             
  213.             
  214.             
  215.             
  216.             
  217.             
  218.             
  219.             
  220.             // **************** Leggo parametri decryption store **************************
  221.             KeyStore decryptionKS = null;
  222.             KeyStore decryptionTrustStoreKS = null;
  223.             String aliasDecryptUser = null;
  224.             String aliasDecryptPassword = null;
  225.             boolean decryptionSymmetric = false;
  226.             if(decrypt){
  227.                 EncryptionBean bean = KeystoreUtils.getReceiverEncryptionBean(messageSecurityContext,ctx);
  228.                 
  229.                 decryptionKS = bean.getKeystore();
  230.                 decryptionTrustStoreKS = bean.getTruststore();
  231.                 decryptionSymmetric = bean.isEncryptionSimmetric();
  232.                 aliasDecryptUser = bean.getUser();
  233.                 aliasDecryptPassword = bean.getPassword();
  234.             
  235.             }
  236.             
  237.             
  238.             
  239.             
  240.             // **************** Leggo parametri signature store **************************
  241.             KeyStore signatureKS = null;
  242.             KeyStore signatureTrustStoreKS = null;
  243.             String aliasSignatureUser = null;
  244.             String aliasSignaturePassword = null;
  245.             String crlPath = null;
  246.             if(signature){
  247.                 
  248.                 SignatureBean bean = KeystoreUtils.getReceiverSignatureBean(messageSecurityContext,ctx);
  249.                 
  250.                 signatureKS = bean.getKeystore();
  251.                 signatureTrustStoreKS = bean.getTruststore();
  252.                 aliasSignatureUser = bean.getUser();
  253.                 aliasSignaturePassword = bean.getPassword();
  254.                 crlPath = bean.getCrlPath();

  256.             }
  257.             
  258.             
  259.             
  260.             
  261.             
  262.             
  263.             
  264.             
  265.             
  266.             
  267.             // **************** Inizializzo Secure Context for encryption **************************
  268.             org.openspcoop2.security.message.soapbox.SoapBoxSecurityConfig securityConfig_decryption = null;
  269.             if(decrypt){            
  270.                 msgSecCtx.getEncryptionRequest().setCertAlias(aliasDecryptUser);
  271.                 
  272.                 Map<String, String> passwordMap_decryption = new HashMap<>();
  273.                 passwordMap_decryption.put(aliasDecryptUser, aliasDecryptPassword);
  274.                 if(decryptionTrustStoreKS==null){
  275.                     decryptionTrustStoreKS = decryptionKS;
  276.                 }
  277.                 securityConfig_decryption = new org.openspcoop2.security.message.soapbox.SoapBoxSecurityConfig(decryptionKS, decryptionTrustStoreKS, passwordMap_decryption,ctx);
  278.                 securityConfig_decryption.setSymmetricSharedKey(decryptionSymmetric);
  279.             }
  280.             
  281.             
  282.             
  283.             
  284.             
  285.             
  286.             
  287.             
  288.             
  289.             // **************** Inizializzo Secure Context for signature **************************
  290.             org.openspcoop2.security.message.soapbox.SoapBoxSecurityConfig securityConfig_signature = null;
  291.             if(signature){          
  292.                 Map<String, String> passwordMap_signature = new HashMap<>();
  293.                 passwordMap_signature.put(aliasSignatureUser, aliasSignaturePassword);
  294.                 if(signatureTrustStoreKS==null){
  295.                     signatureTrustStoreKS = signatureKS;
  296.                 }
  297.                 securityConfig_signature = new org.openspcoop2.security.message.soapbox.SoapBoxSecurityConfig(signatureKS, signatureTrustStoreKS, passwordMap_signature,crlPath,ctx);
  298.             }   
  299.             
  300.             
  301.             
  302.             
  303.             
  304.             
  305.             
  306.             
  307.             
  308.             // **************** Process **************************

  310.             // Devo rileggerle per eseguire nell'ordine
  311.             actions = ((String)messageSecurityContext.getIncomingProperties().get(SecurityConstants.ACTION)).split(" ");
  312.             for (int i = actions.length-1; i >= 0; i--) {
  313.                 if(SecurityConstants.isActionEncryption(actions[i].trim()) || SecurityConstants.isActionDecryption(actions[i].trim())){
  314.                     decryptMsgProc.process(securityConfig_decryption, msgSecCtx);
  315.                     //refreshAttachments(message); // per impostare il nuovo contenuto degli attachment, una volta decriptati (non serve se non si imposta il CONTENT_TRANSFER_ENCODING a base64!!)
  316.                 }
  317.                 else if(SecurityConstants.SIGNATURE_ACTION.equals(actions[i].trim())){
  318.                     signMsgProc.process(securityConfig_signature, msgSecCtx);
  319.                     this.certificates = signMsgProc.getCertificates();
  320.                 }
  321.                 else if(SecurityConstants.TIMESTAMP_ACTION.equals(actions[i].trim())){
  322.                     if(securityConfig_signature!=null){
  323.                         verifyTimestampedProc.process(securityConfig_signature, msgSecCtx);
  324.                     }
  325.                     else if(securityConfig_decryption!=null){
  326.                         verifyTimestampedProc.process(securityConfig_decryption, msgSecCtx);
  327.                     } else {
  328.                         verifyTimestampedProc.process(null, msgSecCtx);
  329.                     }
  330.                 }
  331.             }
  332.             
  333.             
  334.             
  335.             
  336.             
  337.             
  338.             
  339.             
  340.             
  341.         } catch (Exception e) {
  342.             
  343.             SecurityException wssException = new SecurityException(e.getMessage(), e);
  344.             
  345.             
  346.             /* **** MESSAGGIO ***** */
  347.             String msg = Utilities.getInnerNotEmptyMessageException(e).getMessage();
  348.             
  349.             Throwable innerExc = Utilities.getLastInnerException(e);
  350.             String innerMsg = null;
  351.             if(innerExc!=null){
  352.                 innerMsg = innerExc.getMessage();
  353.             }
  354.             
  355.             String messaggio = null;
  356.             if(msg!=null){
  357.                 messaggio = new String(msg);
  358.                 if(innerMsg!=null && !innerMsg.equals(msg)){
  359.                     messaggio = messaggio + " ; " + innerMsg;
  360.                 }
  361.             }
  362.             else{
  363.                 if(innerMsg!=null){
  364.                     messaggio = innerMsg;
  365.                 }
  366.             }
  367.             
  368.             wssException.setMsgErrore(messaggio);
  369.             
  370.             

  372.             /* ***** CODICE **** */
  373.             
  374.             boolean signature = false;
  375.             boolean encrypt = false;
  376.             try{
  377.                 ByteArrayOutputStream bout = new ByteArrayOutputStream();
  378.                 PrintStream printStream = new PrintStream(bout);
  379.                 e.printStackTrace(printStream);
  380.                 bout.flush();
  381.                 printStream.flush();
  382.                 bout.close();
  383.                 printStream.close();
  384.                 
  385.                 if(bout.toString().contains("ProcessSignedMessage")){
  386.                     signature = true;
  387.                 }
  388.                 else if(bout.toString().contains("Signature verification failed")){
  389.                     signature = true;
  390.                 }
  391.                 else if(bout.toString().contains("Message is not signed")){
  392.                     signature = true;
  393.                 }
  394.                 else if(bout.toString().contains("ProcessPartialEncryptedMessage")){
  395.                     encrypt = true;
  396.                 }
  397.                 
  398.             }catch(Exception eClose){}
  399.             
  400.             if(signature){
  401.                 wssException.setCodiceErrore(CodiceErroreCooperazione.SICUREZZA_FIRMA_NON_VALIDA);
  402.             }
  403.             else if(encrypt){
  404.                 wssException.setCodiceErrore(CodiceErroreCooperazione.SICUREZZA_CIFRATURA_NON_VALIDA);
  405.             }
  406.             else {
  407.                 wssException.setCodiceErrore(CodiceErroreCooperazione.SICUREZZA);
  408.             }
  409.             
  410.             
  411.             
  412.             throw wssException;
  413.         }

  415.     }

  417.     @SuppressWarnings("unused")
  418.     private void refreshAttachments(OpenSPCoop2SoapMessage openspcoop2Message) throws MessageException, MessageNotSupportedException, SOAPException{
  419.         java.util.Iterator<?> itAp = openspcoop2Message.getAttachments();
  420.         List<AttachmentPart> v = new ArrayList<AttachmentPart>();
  421.         while(itAp.hasNext()){
  422.             AttachmentPart ap = 
  423.                 (AttachmentPart) itAp.next();
  424.             v.add(ap);
  425.         }
  426.         openspcoop2Message.removeAllAttachments();
  427.         while(v.size()>0){
  428.             AttachmentPart ap = v.remove(0);
  429.             AttachmentPart apNew = openspcoop2Message.createAttachmentPart();
  430.             apNew.setDataHandler(ap.getDataHandler());
  431.             Iterator<?> itMhs = ap.getAllMimeHeaders();
  432.             while (itMhs.hasNext()) {
  433.                 javax.xml.soap.MimeHeader mh = (javax.xml.soap.MimeHeader) itMhs.next();
  434.                 //System.out.println("TIPO["+mh.getName()+"] VALUE["+mh.getValue()+"]");
  435.                 if(!"Content-Transfer-Encoding".equals(mh.getName())){
  436.                     apNew.addMimeHeader(mh.getName(), mh.getValue());
  437.                 }
  438.             }
  439.             openspcoop2Message.addAttachmentPart(apNew);
  440.         }
  441.     } 
  442.     

  444.     
  445.     @Override
  446.     public String getCertificate() throws SecurityException{
  447.         if(this.certificates!=null &&
  448.             this.certificates.length > 0){
  449.             return this.certificates[0].getSubjectX500Principal().toString();
  450.         }
  451.         return null;
  452.     }
  453.     
  454.     @Override
  455.     public X509Certificate getX509Certificate() throws SecurityException {
  456.         if(this.certificates!=null &&
  457.             this.certificates.length > 0){
  458.             return this.certificates[0];
  459.         }
  460.         return null;
  461.     }

  463.     @Override
  464.     public PublicKey getPublicKey() {
  465.         if(this.certificates!=null &&
  466.             this.certificates.length > 0){
  467.             return this.certificates[0].getPublicKey();
  468.         }
  469.         return null;
  470.     }
  471.     
  472.     @Override
  473.     public String getCertificateId() throws SecurityException{
  474.         return null;
  475.     }
  476.     

  478.     @Override
  479.     public List<Reference> getDirtyElements(
  480.             org.openspcoop2.security.message.MessageSecurityContext messageSecurityContext,
  481.             OpenSPCoop2SoapMessage message) throws SecurityException {
  482.         return WSSUtilities.getDirtyElements(messageSecurityContext, message);
  483.     }

  485.     @Override
  486.     public Map<QName, QName> checkEncryptSignatureParts(
  487.             org.openspcoop2.security.message.MessageSecurityContext messageSecurityContext,
  488.             List<Reference> elementsToClean, OpenSPCoop2SoapMessage message,
  489.             List<SubErrorCodeSecurity> codiciErrore) throws SecurityException {
  490.         return MessageUtilities.checkEncryptSignatureParts(messageSecurityContext, elementsToClean, message, codiciErrore, SecurityConstants.QNAME_WSS_ELEMENT_SECURITY);
  491.     }

  493.     @Override
  494.     public void checkEncryptionPartElements(Map<QName, QName> notResolved,
  495.             OpenSPCoop2SoapMessage message,
  496.             List<SubErrorCodeSecurity> erroriRilevati) throws SecurityException {
  497.         MessageUtilities.checkEncryptionPartElements(notResolved, message, erroriRilevati);
  498.     }

  500.     @Override
  501.     public void cleanDirtyElements(
  502.             org.openspcoop2.security.message.MessageSecurityContext messageSecurityContext,
  503.             OpenSPCoop2SoapMessage message, List<Reference> elementsToClean,
  504.             boolean detachHeaderWSSecurity, boolean removeAllIdRef)
  505.             throws SecurityException {
  506.         WSSUtilities.cleanDirtyElements(messageSecurityContext, message, elementsToClean, detachHeaderWSSecurity,removeAllIdRef);
  507.         
  508.     }

  510.     
  511. }
Created with JaCoCo 0.8.8.202204050719