WSSUtilities.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.  */

  21. package org.openspcoop2.security.message.wss4j;

  23. import java.io.InputStream;
  24. import java.util.ArrayList;
  25. import java.util.Iterator;
  26. import java.util.List;

  28. import javax.activation.DataHandler;
  29. import javax.xml.soap.AttachmentPart;
  30. import javax.xml.soap.MimeHeader;
  31. import javax.xml.soap.MimeHeaders;
  32. import javax.xml.transform.Source;
  33. import javax.xml.transform.dom.DOMSource;

  35. import org.apache.commons.codec.binary.Base64InputStream;
  36. import org.apache.commons.lang.StringEscapeUtils;
  37. import org.apache.cxf.attachment.AttachmentImpl;
  38. import org.apache.cxf.binding.soap.SoapMessage;
  39. import org.apache.cxf.message.Attachment;
  40. import org.apache.wss4j.dom.engine.WSSecurityEngineResult;
  41. import org.apache.wss4j.dom.handler.WSHandlerResult;
  42. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  43. import org.openspcoop2.message.xml.MessageXMLUtils;
  44. import org.openspcoop2.security.message.constants.SecurityConstants;
  45. import org.openspcoop2.security.message.utils.AttachmentProcessingPart;
  46. import org.openspcoop2.utils.Utilities;
  47. import org.openspcoop2.utils.dch.InputStreamDataSource;
  48. import org.openspcoop2.utils.io.Base64Utilities;
  49. import org.openspcoop2.utils.regexp.RegularExpressionEngine;
  50. import org.openspcoop2.utils.transport.http.HttpConstants;
  51. import org.slf4j.Logger;
  52. import org.w3c.dom.Node;

  54. /**
  55.  * WSSUtilities
  56.  *
  57.  * @author Lorenzo Nardi (nardi@link.it)
  58.  * @author Tommaso Burlon (tommaso.burlon@link.it)
  59.  * @author $Author$
  60.  * @version $Rev$, $Date$
  61.  */
  62. public class WSSUtilities {

  64.     public static void printWSResult(Logger log,List<?> results){
  65.         if(results!=null){
  66.             Iterator<?> it = results.iterator();
  67.             while (it.hasNext()) {
  68.                 Object object = it.next();
  69.                 if(object instanceof WSHandlerResult){
  70.                     WSHandlerResult wsResult = (WSHandlerResult) object;
  71.                     log.debug("Actor ["+wsResult.getActor()+"]");
  72.                     List<WSSecurityEngineResult> wsResultList =  wsResult.getResults();
  73.                     if(wsResultList!=null){
  74.                         for (int i = 0; i < wsResultList.size(); i++) {
  75.                             log.debug("WSResult["+i+"]="+wsResultList.get(i).toString());
  76.                         }
  77.                     }
  78.                 }
  79.             }
  80.         }
  81.     }
  82.     
  83.     public static List<Attachment> readAttachments(List<String> cidAttachmentsForSecurity,OpenSPCoop2SoapMessage message, SoapMessage msgCtx) throws Exception{
  84.         List<Attachment> listAttachments = null;
  85.         if(cidAttachmentsForSecurity!=null && cidAttachmentsForSecurity.size()>0){
  86.             listAttachments = new ArrayList<Attachment>();
  87.             for (String cid : cidAttachmentsForSecurity) {              
  88.                 //System.out.println("GET ID ["+cid+"]");
  89.                 MimeHeaders mhs = new MimeHeaders();
  90.                 mhs.addHeader(HttpConstants.CONTENT_ID, cid);
  91.                 Iterator<?> itAttach = message.getAttachments(mhs);
  92.                 if(itAttach==null){
  93.                     throw new Exception("Attachment with Content-ID ["+cid+"] not found");
  94.                 }
  95.                 AttachmentPart ap = (AttachmentPart) itAttach.next();
  96.                 if(ap==null){
  97.                     throw new Exception("Attachment with Content-ID ["+cid+"] not found");
  98.                 }
  99.                 listAttachments.add(convertToCxfAttachment(ap, msgCtx));
  100.             }
  101.         }
  102.         return listAttachments;
  103.     }
  104.     
  105.     public static List<Attachment> readAttachments(AttachmentProcessingPart app,OpenSPCoop2SoapMessage message, SoapMessage msgCtx) throws Exception{
  106.         List<Attachment> listAttachments = null;
  107.         if(app!=null){
  108.             List<AttachmentPart> listApDaTrattare = app.getOutput(message);
  109.             if(listApDaTrattare!=null && listApDaTrattare.size()>0){
  110.                 listAttachments = new ArrayList<Attachment>();
  111.                 for (int i = 0; i < listApDaTrattare.size(); i++) {
  112.                     AttachmentPart ap = listApDaTrattare.get(i);
  113.                     //System.out.println("AP ["+ap.getContentId()+"] ["+StringEscapeUtils.escapeXml(ap.getContentId())+"] ["+ap.getContentType()+"] add");
  114.                     listAttachments.add(convertToCxfAttachment(ap, msgCtx));
  115.                 }
  116.             }
  117.         }
  118.         return listAttachments;
  119.     }
  120.     
  121.     private static Attachment convertToCxfAttachment(AttachmentPart ap, SoapMessage msgCtx) throws Exception{
  122.         DataHandler dh = ap.getDataHandler();
  123.         DataHandler dhNEW = null;
  124.         byte[]bufferArray = null;
  125.         String s = null;
  126.         boolean encodeBase64 = msgCtx.containsKey(SecurityConstants.PRE_BASE64_ENCODING_ATTACHMENT) ?
  127.                 msgCtx.get(SecurityConstants.PRE_BASE64_ENCODING_ATTACHMENT).equals(SecurityConstants.PRE_BASE64_ENCODING_ATTACHMENT_TRUE) :
  128.                 SecurityConstants.PRE_BASE64_ENCODING_ATTACHMENT_DEFAULT;

  130.         if(dh.getContentType()!=null && dh.getContentType().startsWith(HttpConstants.CONTENT_TYPE_PLAIN) && !encodeBase64){
  131.             dhNEW = dh;
  132.         }
  133.         else if(!encodeBase64 && (RegularExpressionEngine.isMatch(dh.getContentType(),".*\\/xml")
  134.                 ||
  135.                 RegularExpressionEngine.isMatch(dh.getContentType(),".*\\+xml"))){
  136.             dhNEW = dh;
  137.         }
  138.         else{
  139.             try{
  140.                 InputStream ins = null;
  141.                 if (encodeBase64) {
  142.                     ins = new Base64InputStream(dh.getInputStream(), true);
  143.                 } else {
  144.                     ins = dh.getInputStream();
  145.                 }

  147.                 InputStreamDataSource isds = new InputStreamDataSource(ap.getContentId(), dh.getContentType(), ins);
  148.                 dhNEW = new DataHandler(isds);
  149.             }catch(javax.activation.UnsupportedDataTypeException edtx){
  150.                 // eccezione che può essere lanciata da dh.getInputStream() se il datahandler non è stato creato con un datasource

  152.                 // provo a prendere getContent
  153.                 Object o = dh.getContent();
  154.                 if(o!=null){
  155.                     if(o instanceof String){
  156.                         s = (String) o;
  157.                         //System.out.println("SET AS STRING");
  158.                         dhNEW = new DataHandler(s, dh.getContentType());
  159.                     }
  160.                     else if(o instanceof byte[]){
  161.                         bufferArray = (byte[])o;
  162.                         InputStreamDataSource isds = new InputStreamDataSource(ap.getContentId(), dh.getContentType(), bufferArray);
  163.                         dhNEW = new DataHandler(isds);
  164.                     }
  165.                     else if(o instanceof InputStream){
  166.                         InputStreamDataSource isds = new InputStreamDataSource(ap.getContentId(), dh.getContentType(), (InputStream)o);
  167.                         dhNEW = new DataHandler(isds);
  168.                     }
  169.                     else{
  170.                         throw new Exception("Attach ["+ap.getContentId()+"] ["+dh.getContentType()+"] with type not supported: "+o.getClass().getName(),edtx);
  171.                     }
  172.                 }
  173.                 else{
  174.                     throw new Exception("Attach ["+ap.getContentId()+"] ["+dh.getContentType()+"] error: "+edtx.getMessage(),edtx);
  175.                 }
  176.             }
  177.             
  178.         }
  179.         
  180.         String id = ap.getContentId();
  181.         boolean addAttachmentIdBrackets = msgCtx.containsKey(SecurityConstants.ADD_ATTACHMENT_ID_BRACKETS) ?
  182.                 msgCtx.get(SecurityConstants.ADD_ATTACHMENT_ID_BRACKETS).equals(SecurityConstants.ADD_ATTACHMENT_ID_BRACKETS_TRUE) :
  183.                     SecurityConstants.ADD_ATTACHMENT_ID_BRACKETS_DEFAULT;
  184.         if (!addAttachmentIdBrackets) {
  185.             id = id.replaceAll("(^<)|(>$)", "");
  186.         }

  188.         AttachmentImpl at = new AttachmentImpl(StringEscapeUtils.escapeXml(id));
  189.         boolean encryptAttachmentsHeader = msgCtx.containsKey(SecurityConstants.ENCRYPT_ATTACHMENT_HEADERS) ?
  190.                 msgCtx.get(SecurityConstants.ENCRYPT_ATTACHMENT_HEADERS).equals(SecurityConstants.ENCRYPT_ATTACHMENT_HEADERS_TRUE) :
  191.                     SecurityConstants.ENCRYPT_ATTACHMENT_HEADERS_DEFAULT;
  192.         if (encryptAttachmentsHeader) {
  193.             Iterator<MimeHeader> headers = ap.getAllMimeHeaders();
  194.             while (headers.hasNext()) {
  195.                 MimeHeader header = headers.next();
  196.                 at.setHeader(header.getName(), header.getValue());
  197.             }
  198.         }
  199.         
  200.         if (encodeBase64) {
  201.             at.setHeader(HttpConstants.CONTENT_TRANSFER_ENCODING, HttpConstants.CONTENT_TRANSFER_ENCODING_VALUE_BASE64);
  202.         }
  203.         
  204.         at.setDataHandler(dhNEW);
  205.         return at;
  206.     }
  207.     
  208.     private static Object postProcessAttachment(Object o, SoapMessage msgCtx) {
  209.         boolean decodeBase64 = msgCtx.containsKey(SecurityConstants.POST_BASE64_DECODING_ATTACHMENT) ?
  210.                 msgCtx.get(SecurityConstants.POST_BASE64_DECODING_ATTACHMENT).equals(SecurityConstants.POST_BASE64_DECODING_ATTACHMENT_TRUE) :
  211.                 SecurityConstants.POST_BASE64_DECODING_ATTACHMENT_DEFAULT;

  213.         if (decodeBase64) {
  214.             if (o instanceof String) {
  215.                 return new String(Base64Utilities.decode((String) o));
  216.             }
  217.                 
  218.             if (o instanceof byte[]) {
  219.                 return Base64Utilities.decode((byte[])o);
  220.             }
  221.                 
  222.             if (o instanceof InputStream) {
  223.                 return new Base64InputStream((InputStream)o);
  224.             }
  225.         }
  226.         return o;
  227.     }

  229.     public static void updateAttachments(List<Attachment> listAttachments,OpenSPCoop2SoapMessage message, SoapMessage msgCtx) throws Exception{
  230.         if(listAttachments!=null && listAttachments.size()>0){
  231.             boolean decodeBase64 = msgCtx.containsKey(SecurityConstants.POST_BASE64_DECODING_ATTACHMENT) ?
  232.                     msgCtx.get(SecurityConstants.POST_BASE64_DECODING_ATTACHMENT).equals(SecurityConstants.POST_BASE64_DECODING_ATTACHMENT_TRUE) :
  233.                     SecurityConstants.POST_BASE64_DECODING_ATTACHMENT_DEFAULT;
  234.             boolean encodeBase64 = msgCtx.containsKey(SecurityConstants.POST_BASE64_ENCODING_ATTACHMENT) ?
  235.                     msgCtx.get(SecurityConstants.POST_BASE64_ENCODING_ATTACHMENT).equals(SecurityConstants.POST_BASE64_ENCODING_ATTACHMENT_TRUE) :
  236.                     SecurityConstants.POST_BASE64_ENCODING_ATTACHMENT_DEFAULT;

  238.             for (Attachment attachmentPart : listAttachments) {
  239.                 MimeHeaders mhs = new MimeHeaders();
  240.                 mhs.addHeader(HttpConstants.CONTENT_ID, StringEscapeUtils.unescapeXml(attachmentPart.getId()));

  242.                 AttachmentPart ap = (AttachmentPart) message.getAttachments(mhs).next();
  243.                 if (encodeBase64)
  244.                     ap.addMimeHeader(HttpConstants.CONTENT_TRANSFER_ENCODING, HttpConstants.CONTENT_TRANSFER_ENCODING_VALUE_BASE64);
  245.                 if (decodeBase64)
  246.                     ap.addMimeHeader(HttpConstants.CONTENT_TRANSFER_ENCODING, HttpConstants.CONTENT_TRANSFER_ENCODING_VALUE_BINARY);

  248.                 DataHandler dh = attachmentPart.getDataHandler();
  249.                 byte[]bufferArray = null;
  250.                 String s = null;
  251.                 if(dh.getContentType()!=null && dh.getContentType().startsWith(HttpConstants.CONTENT_TYPE_PLAIN)){
  252.                     Object o = dh.getContent();
  253.                     if(o instanceof String){
  254.                         s = (String) postProcessAttachment(o, msgCtx);
  255.                         message.updateAttachmentPart(ap, s, dh.getContentType());
  256.                     }
  257.                     else if(o instanceof byte[]){
  258.                         bufferArray = (byte[]) postProcessAttachment(o, msgCtx);
  259.                         message.updateAttachmentPart(ap, bufferArray, dh.getContentType());
  260.                     }
  261.                     else if(o instanceof InputStream){
  262.                         bufferArray = Utilities.getAsByteArray((InputStream)postProcessAttachment(o, msgCtx));
  263.                         message.updateAttachmentPart(ap, bufferArray, dh.getContentType());
  264.                     }
  265.                     else{
  266.                         throw new Exception("Attach-Plain ["+attachmentPart.getId()+"] ["+dh.getContentType()+"] with type not supported: "+o.getClass().getName());
  267.                     }
  268.                 }
  269.                 else if(RegularExpressionEngine.isMatch(dh.getContentType(),".*\\/xml")
  270.                         ||
  271.                         RegularExpressionEngine.isMatch(dh.getContentType(),".*\\+xml")){
  272.                     // potenziale xml
  273.                     
  274.                     Object o = dh.getContent();
  275.                     boolean testXml = false;
  276.                     boolean updated = false;
  277.                     Node n = null;
  278.                     if(o instanceof String){
  279.                         s = (String) postProcessAttachment(o, msgCtx);
  280.                         //System.out.println("SET AS STRING");
  281.                         message.updateAttachmentPart(ap, s, dh.getContentType());
  282.                         updated = true;
  283.                     }
  284.                     else if(o instanceof byte[]){
  285.                         bufferArray = (byte[])postProcessAttachment(o, msgCtx);
  286.                         //System.out.println("SET AS SOURCE (byte[])");
  287.                         testXml = true;
  288.                     }
  289.                     else if(o instanceof InputStream){
  290.                         bufferArray = Utilities.getAsByteArray((InputStream)postProcessAttachment(o, msgCtx));
  291.                         //System.out.println("SET AS SOURCE (IS)");
  292.                         testXml = true;
  293.                     }
  294.                     else if(o instanceof Node){
  295.                         n = (Node) postProcessAttachment(o, msgCtx);
  296.                         //System.out.println("SET AS SOURCE (NODE)");
  297.                     }
  298.                     else{
  299.                         throw new Exception("Attach-XML ["+attachmentPart.getId()+"] ["+dh.getContentType()+"] with type not supported: "+o.getClass().getName());
  300.                     }
  301.                     
  302.                     if(testXml){
  303.                         try{
  304.                             if(n==null){
  305.                                 n = MessageXMLUtils.getInstance(message.getFactory()).newElement(bufferArray);
  306.                             }
  307.                         }catch(Exception e){
  308.                             // no xml
  309.                             message.updateAttachmentPart(ap, bufferArray, dh.getContentType());
  310.                             updated = true;
  311.                         }
  312.                     }
  313.                     
  314.                     if(updated==false){
  315.                         Source streamSource = new DOMSource(n);
  316.                         DataHandler newDH = new DataHandler(streamSource, dh.getContentType());
  317.                         message.updateAttachmentPart(ap,newDH);
  318.                     }
  319.                 }
  320.                 else{
  321.                     try{
  322.                         InputStream ins = (InputStream) postProcessAttachment(dh.getInputStream(), msgCtx);
  323.                         InputStreamDataSource isds = new InputStreamDataSource(attachmentPart.getId(), dh.getContentType(), ins);
  324.                         DataHandler dhNEW = new DataHandler(isds);
  325.                         message.updateAttachmentPart(ap, dhNEW);
  326.                     }catch(javax.activation.UnsupportedDataTypeException edtx){
  327.                         // eccezione che può essere lanciata da dh.getInputStream() se il datahandler non è stato creato con un datasource

  329.                         // provo a prendere getContent
  330.                         Object o = dh.getContent();
  331.                         DataHandler dhNEW = null;
  332.                         if(o!=null){
  333.                             if(o instanceof String){
  334.                                 s = (String) o;
  335.                                 //System.out.println("SET AS STRING");
  336.                                 dhNEW = new DataHandler(s, dh.getContentType());
  337.                             }
  338.                             else if(o instanceof byte[]){
  339.                                 bufferArray = (byte[])o;
  340.                                 InputStreamDataSource isds = new InputStreamDataSource(attachmentPart.getId(), dh.getContentType(), bufferArray);
  341.                                 dhNEW = new DataHandler(isds);
  342.                             }
  343.                             else if(o instanceof InputStream){
  344.                                 InputStreamDataSource isds = new InputStreamDataSource(attachmentPart.getId(), dh.getContentType(), (InputStream)o);
  345.                                 dhNEW = new DataHandler(isds);
  346.                             }
  347.                             else{
  348.                                 throw new Exception("Attach ["+ap.getContentId()+"] ["+dh.getContentType()+"] with type not supported: "+o.getClass().getName(),edtx);
  349.                             }
  350.                         }
  351.                         else{
  352.                             throw new Exception("Attach ["+ap.getContentId()+"] ["+dh.getContentType()+"] error: "+edtx.getMessage(),edtx);
  353.                         }
  354.                         message.updateAttachmentPart(ap, dhNEW);
  355.                     }
  356.                 }
  357.             }
  358.         }
  359.     }
  360.     
  361. }
Created with JaCoCo 0.8.8.202204050719