MessageUtilities.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.engine;

  23. import java.util.ArrayList;
  24. import java.util.HashMap;
  25. import java.util.Iterator;
  26. import java.util.List;
  27. import java.util.Map;

  29. import javax.xml.namespace.QName;
  30. import javax.xml.soap.AttachmentPart;

  32. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  33. import org.openspcoop2.message.soap.SoapUtils;
  34. import org.openspcoop2.message.soap.reference.AttachmentReference;
  35. import org.openspcoop2.message.soap.reference.ElementReference;
  36. import org.openspcoop2.message.soap.reference.Reference;
  37. import org.openspcoop2.security.SecurityException;
  38. import org.openspcoop2.security.message.MessageSecurityContext;
  39. import org.openspcoop2.security.message.SubErrorCodeSecurity;
  40. import org.openspcoop2.security.message.constants.SecurityConstants;
  41. import org.w3c.dom.Node;
  42. import org.w3c.dom.NodeList;

  44. /**
  45.  * MessageUtilities
  46.  *
  47.  * @author Andrea Poli (apoli@link.it)
  48.  * @author $Author$
  49.  * @version $Rev$, $Date$
  50.  */
  51. public class MessageUtilities {

  53.     
  54.     public static void checkEncryptionPartElements(Map<QName, QName> notResolved, OpenSPCoop2SoapMessage message, List<SubErrorCodeSecurity> listaErroriInElementi) throws SecurityException {
  55.         
  56.         try{
  57.             
  58.             if(notResolved != null && !notResolved.isEmpty()) {
  59.                 for (QName expected : notResolved.keySet()) {
  60.                     QName actualQName = notResolved.get(expected);
  61.                     boolean found = false;
  62.                     NodeList it = message.getSOAPPart().getElementsByTagNameNS(actualQName.getNamespaceURI(), actualQName.getLocalPart());
  63.                     for (int j = 0; j < it.getLength() && !found; j++) {
  64.                         Node elementFather = (Node) it.item(j);
  65.                         //SOAPElement elementFather = (SOAPElement) it.item(j);
  66.                         //List<SOAPElement> encryptedElements = SoapUtils.getNotEmptyChildSOAPElement(elementFather);
  67.                         List<Node> encryptedElements = SoapUtils.getNotEmptyChildNodes(message.getFactory(), elementFather, false);
  68.                         for (int i = 0; i < encryptedElements.size() && !found; i++) {
  69.                             //SOAPElement actual = encryptedElements.get(i);
  70.                             Node actual = encryptedElements.get(i);
  71.                             String actualNamespaceURI = actual.getNamespaceURI();
  72.                             String actualLocalName = actual.getLocalName();
  73.                             String expectedNamespaceURI = expected.getNamespaceURI();
  74.                             String expectedLocalName = expected.getLocalPart();
  75.                             if(((actualNamespaceURI == null && expectedNamespaceURI == null) || (actualNamespaceURI!=null && actualNamespaceURI.equals(expectedNamespaceURI)))
  76.                                     && actualLocalName.equals(expectedLocalName)) {
  77.                                     //trovato l'elemento che ci interessa
  78.                                     found = true;
  79.                             }
  80.                         }
  81.                     }
  82.                     if(!found) {
  83.                         SubErrorCodeSecurity subCodice = new SubErrorCodeSecurity();
  84.                         subCodice.setEncrypt(true);
  85.                         subCodice.setMsgErrore("Expected encryption part("+ expected +") not found");
  86.                         subCodice.setTipo(SecurityConstants.ENCRYPTION_PART_CONTENT);
  87.                         subCodice.setNamespace(expected.getNamespaceURI());
  88.                         subCodice.setName(expected.getLocalPart());
  89.                         listaErroriInElementi.add(subCodice);
  90.                     }
  91.                 }
  92.             }
  93.             
  94.         }catch(Exception e){
  95.             throw new SecurityException(e.getMessage(),e);
  96.         }
  97.     }

  99.     public static Map<QName, QName> checkEncryptSignatureParts(MessageSecurityContext messageSecurityContext,List<Reference> elementsToClean, OpenSPCoop2SoapMessage message,
  100.             List<SubErrorCodeSecurity> codiciErrore, QName qnameSecurity) throws SecurityException {
  101.         
  102.         Map<String, Object> properties = messageSecurityContext.getIncomingProperties();
  103.         boolean addAttachmentIdBrackets = properties.containsKey(SecurityConstants.ADD_ATTACHMENT_ID_BRACKETS) ?
  104.                 properties.get(SecurityConstants.ADD_ATTACHMENT_ID_BRACKETS).equals(SecurityConstants.ADD_ATTACHMENT_ID_BRACKETS_TRUE) :
  105.                     SecurityConstants.ADD_ATTACHMENT_ID_BRACKETS_DEFAULT;
  106.         try{
  107.             int numAttachmentsInMsg = message.countAttachments();
  108.             List<String> cidAttachments = new ArrayList<>();
  109.             if(numAttachmentsInMsg>0){
  110.                 Iterator<?> itAttach = message.getAttachments();
  111.                 while (itAttach.hasNext()) {
  112.                     AttachmentPart ap = (AttachmentPart) itAttach.next();
  113.                     String cid = ap.getContentId();
  114.                     if (!addAttachmentIdBrackets) {
  115.                         cid = cid.replaceAll("(^<)|(>$)", "");
  116.                     }
  117.                     cidAttachments.add(cid);
  118.                 }
  119.             }
  120.         
  121.             // *** ENCRYPT VERIFY ***
  122.             Map<QName, QName> notResolvedMap = new HashMap<QName, QName>();
  123.             Object encryptionPartsVerify = messageSecurityContext.getIncomingProperties().get(SecurityConstants.ENCRYPTION_PARTS_VERIFY);
  124.             Object encryptionParts = messageSecurityContext.getIncomingProperties().get(SecurityConstants.ENCRYPTION_PARTS);
  125.             if(encryptionPartsVerify!=null && "true".equalsIgnoreCase(((String)encryptionPartsVerify).trim()) &&
  126.                     encryptionParts==null){
  127.                 // Se forzo la proprietà verify allora devo indicare le encryption parts
  128.                 throw new SecurityException(SecurityConstants.ENCRYPTION_PARTS+" non indicate");
  129.             }
  130.             if( (
  131.                     encryptionPartsVerify==null || 
  132.                     "true".equalsIgnoreCase(((String)encryptionPartsVerify).trim())
  133.                 ) &&
  134.                     (encryptionParts!=null) ){
  135.                 
  136.                 Map<String, Boolean> encryptionPartsMap = new HashMap<String, Boolean>();
  137.                 Map<Reference, Boolean> encryptionReferenceMap = new HashMap<Reference, Boolean>();
  138.                 boolean isAllAttachmentEncrypted = false;
  139.                 int numAttachmentsEncrypted = 0;
  140.                 if(encryptionParts!=null){
  141.                     String[]split = ((String)encryptionParts).split(";");
  142.                     int numElementsEncrypted = 0;
  143.                     for (int i = 0; i < split.length; i++) {
  144.                         boolean checked = false;
  145.                         String[]split2 = split[i].trim().split("}");
  146.                         String tipo = split2[0].trim().substring(1); // Element o Content
  147.                         if("".equals(tipo)){
  148.                             // caso speciale wss4j {}cid:Attachments
  149.                             tipo = SecurityConstants.PART_CONTENT;
  150.                         }
  151.                         String namespace = null;
  152.                         String nome = null;
  153.                         boolean attach = false;
  154.                         if(split2.length==3){
  155.                             namespace = split2[1].trim().substring(1); 
  156.                             nome = split2[2].trim();
  157.                             attach = SecurityConstants.ENCRYPTION_NAMESPACE_ATTACH.equals(namespace);
  158.                         }
  159.                         else{
  160.                             // caso speciale wss4j {}cid:Attachments ?
  161.                             if(SecurityConstants.CID_ATTACH_WSS4J.equalsIgnoreCase(split2[1].trim())){
  162.                                 namespace = SecurityConstants.ENCRYPTION_NAMESPACE_ATTACH;
  163.                                 nome = SecurityConstants.ATTACHMENT_INDEX_ALL;
  164.                                 attach = true;
  165.                             }
  166.                             else{
  167.                                 throw new Exception("Part ["+split[i]+"] with wrong format");
  168.                             }
  169.                         }
  170.                         if(SecurityConstants.ENCRYPTION_PART_ELEMENT.equals(tipo)) {
  171.                             // incremento solamente se non è un attachments
  172.                             if(!attach){
  173.                                 numElementsEncrypted++;
  174.                             }
  175.                         }
  176.                         if(nome.startsWith("{"))
  177.                             nome = nome.substring(1);
  178.                         //System.out.println("CIFRO ["+tipo+"] ["+namespace+"] ["+nome+"]");    
  179.                         
  180.                         List<String> cidAttachmentsEncrypt = new ArrayList<>();
  181.                         if(cidAttachments!=null && cidAttachments.size()>0){
  182.                             cidAttachmentsEncrypt.addAll(cidAttachments);
  183.                         }
  184.                         
  185.                         for (Reference reference : elementsToClean) {
  186.                         
  187.                             if(reference instanceof AttachmentReference) {
  188.                                 if(AttachmentReference.TYPE_ENCRYPT_ATTACHMENT==reference.getType()){
  189.                                     if(SecurityConstants.ENCRYPTION_NAMESPACE_ATTACH.equals(namespace)){
  190.                                         numAttachmentsEncrypted++;
  191.                                         if(nome.equals(SecurityConstants.ATTACHMENT_INDEX_ALL)) {
  192.                                             checked = true;
  193.                                             isAllAttachmentEncrypted = true;
  194.                                             encryptionReferenceMap.put(reference, true);
  195.                                             encryptionPartsMap.put(split[i], checked);
  196.                                             // break;
  197.                                             // Vanno iterate tutte, dovendole contare
  198.                                         }else{
  199.                                             int position = -1;
  200.                                             try{
  201.                                                 position = Integer.parseInt(nome);
  202.                                             }catch(Exception e){
  203.                                                 // position non presente
  204.                                             }
  205.                                             if(position>0){
  206.                                                 int refPosition = -1;
  207.                                                 for (int j = 0; j < cidAttachments.size(); j++) {
  208.                                                     if(cidAttachments.get(j).equals(reference.getReference())){
  209.                                                         refPosition = j+1;
  210.                                                         break;
  211.                                                     }
  212.                                                 }
  213.                                                 //if(refPosition == position){ // Alcune implementazioni durante la spedizione modificano l'ordine degli attachments.
  214.                                                 // Non è possibile effettuare tale controllo sulla ricezione. Può essere usato solo per specificare quale attach firmare/cifrare in spedizione
  215.                                                 // verifico solamente che il cid sia presente
  216.                                                 if(refPosition>0){
  217.                                                     cidAttachmentsEncrypt.remove((refPosition-1));
  218.                                                     checked = true;
  219.                                                     encryptionReferenceMap.put(reference, true);
  220.                                                     encryptionPartsMap.put(split[i], checked);
  221.                                                     break;
  222.                                                 }
  223.                                             }
  224.                                             else{
  225.                                                 if(nome.equals(reference.getReference())) {
  226.                                                     checked = true;
  227.                                                     encryptionReferenceMap.put(reference, true);
  228.                                                     encryptionPartsMap.put(split[i], checked);
  229.                                                     break;
  230.                                                 }
  231.                                             }
  232.                                         }
  233.                                     }
  234.                                 }
  235.                             } else {
  236.                                 ElementReference elementReference = ((ElementReference)reference);
  237.                                 String localName = elementReference.getElement().getLocalName();
  238.                                 String namespaceURI = elementReference.getElement().getNamespaceURI();
  239.                                 if(ElementReference.TYPE_ENCRYPT_CONTENT==reference.getType()){
  240.                                     // Check encrypt content
  241.                                     if(nome.equals(localName) && namespace.equals(namespaceURI)) {
  242.                                         checked = SecurityConstants.ENCRYPTION_PART_CONTENT.equals(tipo);
  243.                                         encryptionReferenceMap.put(reference, checked);
  244.                                         encryptionPartsMap.put(split[i], checked);
  245.                                         if(checked){
  246.                                             break;
  247.                                         }
  248.                                     }
  249.                                 } else if(ElementReference.TYPE_ENCRYPT_ELEMENT==reference.getType() && SecurityConstants.ENCRYPTION_PART_ELEMENT.equals(tipo)) {
  250.                                         // Segnamo l'elemento come checked, e lo aggiungiamo alla lista di elementi da verificare 
  251.                                         // dopo la decifratura, visto che allo stato attuale e' imposibile verificarlo
  252.                                         checked = true;
  253.                                         encryptionPartsMap.put(split[i], checked);
  254.                                         QName actual = new QName(namespaceURI, localName);
  255.                                         QName expected = new QName(namespace, nome);
  256.                                         boolean localPartSec = localName.equals(qnameSecurity.getLocalPart());
  257.                                         boolean namespaceURISec = namespaceURI.equals(qnameSecurity.getNamespaceURI()); 
  258.                                         if(!(localPartSec && namespaceURISec)) {
  259.                                             if(!notResolvedMap.containsKey(expected)) {
  260.                                                 notResolvedMap.put(expected, actual);
  261.                                             }
  262.                                         }
  263.                                 }
  264.                             }
  265.                         }
  266.                     }
  267.                     
  268.                     int numElementsExpectedToBeEncrypted = 0;
  269.                     for(Reference reference : elementsToClean) {
  270.                         if(reference.getType()==ElementReference.TYPE_ENCRYPT_ELEMENT) {
  271.                             numElementsExpectedToBeEncrypted++;
  272.                         }
  273.                     }
  274.                     
  275.                     if(numElementsExpectedToBeEncrypted != numElementsEncrypted) {
  276.                         SubErrorCodeSecurity subCodice = new SubErrorCodeSecurity();
  277.                         subCodice.setEncrypt(true);
  278.                         subCodice.setMsgErrore("Expected encryption {Element} " + numElementsExpectedToBeEncrypted + ", found " + notResolvedMap.size());
  279.                         codiciErrore.add(subCodice);
  280.                     }
  281.                 }
  282.                 if(encryptionParts!=null){
  283.                     String[]split = ((String)encryptionParts).split(";");
  284.                     for (int i = 0; i < split.length; i++) {
  285.                         String[]split2 = split[i].trim().split("}");
  286.                         String tipo = split2[0].trim().substring(1); // Element o Content
  287.                         if("".equals(tipo)){
  288.                             // caso speciale wss4j {}cid:Attachments
  289.                             tipo = SecurityConstants.PART_CONTENT;
  290.                         }
  291.                         String namespace = null;
  292.                         String nome = null;
  293.                         if(split2.length==3){
  294.                             namespace = split2[1].trim().substring(1); 
  295.                             nome = split2[2].trim();
  296.                         }
  297.                         else{
  298.                             // caso speciale wss4j {}cid:Attachments ?
  299.                             if(SecurityConstants.CID_ATTACH_WSS4J.equalsIgnoreCase(split2[1].trim())){
  300.                                 namespace = SecurityConstants.ENCRYPTION_NAMESPACE_ATTACH;
  301.                                 nome = SecurityConstants.ATTACHMENT_INDEX_ALL;
  302.                             }
  303.                             else{
  304.                                 throw new Exception("Part ["+split[i]+"] with wrong format");
  305.                             }
  306.                         }
  307.                         if(nome.startsWith("{"))
  308.                             nome = nome.substring(1);
  309.                         if(SecurityConstants.ENCRYPTION_PART_CONTENT.equals(tipo)){
  310.                             if(!encryptionPartsMap.containsKey(split[i]) || !encryptionPartsMap.get(split[i])) {
  311.                                 SubErrorCodeSecurity subCodice = new SubErrorCodeSecurity();
  312.                                 subCodice.setEncrypt(true);
  313.                                 subCodice.setMsgErrore("Expected encryption part("+ split[i] +") not found");
  314.                                 subCodice.setTipo(tipo);
  315.                                 subCodice.setNamespace(namespace);
  316.                                 subCodice.setName(nome);
  317.                                 codiciErrore.add(subCodice);
  318.     //                          throw new Exception("Expected encryption part("+ split[i] +") not found");
  319.                             }
  320.                         }
  321.                     }
  322.                 }
  323.             
  324.                 if(isAllAttachmentEncrypted && numAttachmentsEncrypted != numAttachmentsInMsg) {
  325.                     SubErrorCodeSecurity subCodice = new SubErrorCodeSecurity();
  326.                     subCodice.setEncrypt(true);
  327.                     subCodice.setMsgErrore("All attachments in message (found:"+numAttachmentsInMsg+") must be encrypted, but only "+numAttachmentsEncrypted+" appear to be encrypted");
  328.                     subCodice.setTipo(SecurityConstants.ENCRYPTION_PART_CONTENT);
  329.                     subCodice.setNamespace(SecurityConstants.ENCRYPTION_NAMESPACE_ATTACH);
  330.                     subCodice.setName(SecurityConstants.ATTACHMENT_INDEX_ALL);
  331.                     codiciErrore.add(subCodice);
  332.                     //throw new Exception("All attachments in message (found:"+numAttachmentsInMsg+") must be encrypted, but only "+numAttachmentsEncrypted+" appear to be encrypted");
  333.                 }
  334.                 
  335.                 for (Reference reference: elementsToClean) {
  336.                     if(reference.getType()==ElementReference.TYPE_ENCRYPT_CONTENT || reference.getType()==AttachmentReference.TYPE_ENCRYPT_ATTACHMENT) {
  337.                         if(!encryptionReferenceMap.containsKey(reference) || !encryptionReferenceMap.get(reference)) {
  338.                             SubErrorCodeSecurity subCodice = new SubErrorCodeSecurity();
  339.                             subCodice.setEncrypt(true);
  340.                             subCodice.setMsgErrore("Found encryption part("+ reference+") not expected");
  341.                             if(reference.getType()==ElementReference.TYPE_ENCRYPT_CONTENT){
  342.                                 ElementReference elReference = (ElementReference) reference;
  343.                                 subCodice.setTipo(SecurityConstants.ENCRYPTION_PART_CONTENT);
  344.                                 subCodice.setNamespace(elReference.getElement().getNamespaceURI());
  345.                                 subCodice.setName(elReference.getElement().getLocalName());
  346.                             }
  347.                             else{
  348.                                 subCodice.setTipo(SecurityConstants.ENCRYPTION_PART_CONTENT);
  349.                                 subCodice.setNamespace(SecurityConstants.ENCRYPTION_NAMESPACE_ATTACH);
  350.                                 subCodice.setName(reference.getReference());
  351.                             }
  352.                             codiciErrore.add(subCodice);
  353.                             //throw new Exception("Found encryption part("+ reference+") not expected");
  354.                         }
  355.                     }
  356.                 }
  357.                 
  358.             }
  359.                     
  360.             // *** SIGNATURE VERIFY ***
  361.             Object signaturePartsVerify = messageSecurityContext.getIncomingProperties().get(SecurityConstants.SIGNATURE_PARTS_VERIFY);
  362.             Object signatureParts = messageSecurityContext.getIncomingProperties().get(SecurityConstants.SIGNATURE_PARTS);
  363.             if(signaturePartsVerify!=null && "true".equalsIgnoreCase(((String)signaturePartsVerify).trim()) &&
  364.                     signatureParts==null){
  365.                 // Se forzo la proprietà verify allora devo indicare le signature parts
  366.                 throw new SecurityException(SecurityConstants.SIGNATURE_PARTS+" non indicate");
  367.             }
  368.             if( (
  369.                     signaturePartsVerify==null || 
  370.                     "true".equalsIgnoreCase(((String)signaturePartsVerify).trim())
  371.                 ) &&
  372.                     (signatureParts!=null) ){
  373.                     
  374.                 boolean isAllAttachmentSigned = false;
  375.                 int numAttachmentsSigned = 0;
  376.                 Map<String, Boolean> signaturePartsMap = new HashMap<String, Boolean>();
  377.                 Map<Reference, Boolean> referenceMap = new HashMap<Reference, Boolean>();
  378.                 if(signatureParts!=null){
  379.                     String[]split = ((String)signatureParts).split(";");
  380.                     for (int i = 0; i < split.length; i++) {
  381.                         boolean checked = false;
  382.                         String[]split2 = split[i].trim().split("}");
  383.                         String tipo = split2[0].trim().substring(1); // Element o Content
  384.                         if("".equals(tipo)){
  385.                             // caso speciale wss4j {}cid:Attachments
  386.                             tipo = SecurityConstants.PART_CONTENT;
  387.                         }
  388.                         String namespace = null;
  389.                         String nome = null;
  390.                         if(split2.length==3){
  391.                             namespace = split2[1].trim().substring(1); 
  392.                             nome = split2[2].trim();
  393.                         }
  394.                         else{
  395.                             // caso speciale wss4j {}cid:Attachments ?
  396.                             if(SecurityConstants.CID_ATTACH_WSS4J.equalsIgnoreCase(split2[1].trim())){
  397.                                 namespace = SecurityConstants.SIGNATURE_NAMESPACE_ATTACH;
  398.                                 nome = SecurityConstants.ATTACHMENT_INDEX_ALL;
  399.                             }
  400.                             else{
  401.                                 throw new Exception("Part ["+split[i]+"] with wrong format");
  402.                             }
  403.                         }
  404.                         if(nome.startsWith("{"))
  405.                             nome = nome.substring(1);
  406.                         //System.out.println("CIFRO ["+tipo+"] ["+namespace+"] ["+nome+"]");    
  407.                         
  408.                         List<String> cidAttachmentsSignature = new ArrayList<>();
  409.                         if(cidAttachments!=null && cidAttachments.size()>0){
  410.                             cidAttachmentsSignature.addAll(cidAttachments);
  411.                         }
  412.                         
  413.                         for (Reference reference : elementsToClean) {
  414.                         
  415.                             if(reference instanceof AttachmentReference) {
  416.                                 if(AttachmentReference.TYPE_SIGN_ATTACHMENT==reference.getType()){
  417.                                     if(SecurityConstants.SIGNATURE_NAMESPACE_ATTACH.equals(namespace)){
  418.                                         numAttachmentsSigned++;
  419.                                         if(nome.equals(SecurityConstants.ATTACHMENT_INDEX_ALL)) {
  420.                                             checked = true;
  421.                                             isAllAttachmentSigned = true;
  422.                                             referenceMap.put(reference, true);
  423.                                             // break;
  424.                                             // Vanno iterate tutte, dovendole contare
  425.                                         }
  426.                                         else{
  427.                                             int position = -1;
  428.                                             try{
  429.                                                 position = Integer.parseInt(nome);
  430.                                             }catch(Exception e){
  431.                                                 // position non presente
  432.                                             }
  433.                                             if(position>0){
  434.                                                 int refPosition = -1;
  435.                                                 for (int j = 0; j < cidAttachments.size(); j++) {
  436.                                                     if(cidAttachments.get(j).equals(reference.getReference())){
  437.                                                         refPosition = j+1;
  438.                                                         break;
  439.                                                     }
  440.                                                 }
  441.                                                 //if(refPosition == position){ // Alcune implementazioni durante la spedizione modificano l'ordine degli attachments.
  442.                                                 // Non è possibile effettuare tale controllo sulla ricezione. Può essere usato solo per specificare quale attach firmare/cifrare in spedizione
  443.                                                 // verifico solamente che il cid sia presente
  444.                                                 if(refPosition>0){
  445.                                                     cidAttachmentsSignature.remove((refPosition-1));
  446.                                                     checked = true;
  447.                                                     referenceMap.put(reference, true);
  448.                                                     break;
  449.                                                 }
  450.                                             }
  451.                                             else{
  452.                                                 if(nome.equals(reference.getReference())) {
  453.                                                     checked = true;
  454.                                                     referenceMap.put(reference, true);
  455.                                                     break;
  456.                                                 }
  457.                                             }
  458.                                         }
  459.                                     }
  460.                                 }
  461.                             } else {
  462.                                 ElementReference elementReference = ((ElementReference)reference);
  463.                                 String localName = elementReference.getElement().getLocalName();
  464.                                 String namespaceURI = elementReference.getElement().getNamespaceURI();
  465.                                 if(ElementReference.TYPE_SIGNATURE==reference.getType() && nome.equals(localName) && namespace.equals(namespaceURI)) {
  466.                                     checked = SecurityConstants.SIGNATURE_PART_COMPLETE.equals(tipo) ||
  467.                                             SecurityConstants.SIGNATURE_PART_CONTENT.equals(tipo) || SecurityConstants.SIGNATURE_PART_ELEMENT.equals(tipo);
  468.                                     referenceMap.put(reference, checked);
  469.                                     if(checked){
  470.                                         break;
  471.                                     }
  472.                                 }
  473.                             }
  474.                         }
  475.                         signaturePartsMap.put(split[i], checked);
  476.                     }
  477.                 }
  478.                 
  479.                 for (String part : signaturePartsMap.keySet()) {
  480.                     if(!signaturePartsMap.get(part)) {
  481.                         String[]split2 = part.trim().split("}");
  482.                         String tipo = split2[0].trim().substring(1); // Element o Content
  483.                         if("".equals(tipo)){
  484.                             // caso speciale wss4j {}cid:Attachments
  485.                             tipo = SecurityConstants.PART_CONTENT;
  486.                         }
  487.                         String namespace = null;
  488.                         String nome = null;
  489.                         if(split2.length==3){
  490.                             namespace = split2[1].trim().substring(1); 
  491.                             nome = split2[2].trim();
  492.                         }
  493.                         else{
  494.                             // caso speciale wss4j {}cid:Attachments ?
  495.                             if(SecurityConstants.CID_ATTACH_WSS4J.equalsIgnoreCase(split2[1].trim())){
  496.                                 namespace = SecurityConstants.SIGNATURE_NAMESPACE_ATTACH;
  497.                                 nome = SecurityConstants.ATTACHMENT_INDEX_ALL;
  498.                             }
  499.                             else{
  500.                                 throw new Exception("Part ["+part+"] with wrong format");
  501.                             }
  502.                         }
  503.                         if(nome.startsWith("{"))
  504.                             nome = nome.substring(1);
  505.                         SubErrorCodeSecurity subCodice = new SubErrorCodeSecurity();
  506.                         subCodice.setEncrypt(false);
  507.                         subCodice.setMsgErrore("Expected signature part("+ part +") not found");
  508.                         subCodice.setTipo(tipo);
  509.                         subCodice.setNamespace(namespace);
  510.                         subCodice.setName(nome);
  511.                         codiciErrore.add(subCodice);
  512.                         //throw new Exception("Expected signature part("+ part +") not found");
  513.                     }
  514.                 }
  515.                 
  516.         
  517.                 if(isAllAttachmentSigned && numAttachmentsSigned != numAttachmentsInMsg) {
  518.                     SubErrorCodeSecurity subCodice = new SubErrorCodeSecurity();
  519.                     subCodice.setEncrypt(false);
  520.                     subCodice.setMsgErrore("All attachments in message (found:"+numAttachmentsInMsg+") must be signed, but only "+numAttachmentsSigned+" appear to be signed");
  521.                     subCodice.setTipo(SecurityConstants.SIGNATURE_PART_CONTENT);
  522.                     subCodice.setNamespace(SecurityConstants.SIGNATURE_NAMESPACE_ATTACH);
  523.                     subCodice.setName(SecurityConstants.ATTACHMENT_INDEX_ALL);
  524.                     codiciErrore.add(subCodice);
  525.                     //throw new Exception("All attachments in message (found:"+numAttachmentsInMsg+") must be signed, but "+numAttachmentsSigned+" appear to be signed");
  526.                 }
  527.                 
  528.                 for (Reference reference: elementsToClean) {
  529.                     if(reference.getType()==ElementReference.TYPE_SIGNATURE || reference.getType()==AttachmentReference.TYPE_SIGN_ATTACHMENT) {
  530.                         if(!referenceMap.containsKey(reference) || !referenceMap.get(reference)) {
  531.                             SubErrorCodeSecurity subCodice = new SubErrorCodeSecurity();
  532.                             subCodice.setEncrypt(false);
  533.                             subCodice.setMsgErrore("Found signature part("+ reference+") not expected");
  534.                             if(reference.getType()==ElementReference.TYPE_SIGNATURE){
  535.                                 ElementReference elReference = (ElementReference) reference;
  536.                                 subCodice.setTipo("Signature"); // Non esiste Content/Element
  537.                                 subCodice.setNamespace(elReference.getElement().getNamespaceURI());
  538.                                 subCodice.setName(elReference.getElement().getLocalName());
  539.                             }
  540.                             else{
  541.                                 subCodice.setTipo(SecurityConstants.SIGNATURE_PART_CONTENT);
  542.                                 subCodice.setNamespace(SecurityConstants.ENCRYPTION_NAMESPACE_ATTACH);
  543.                                 subCodice.setName(reference.getReference());
  544.                             }
  545.                             codiciErrore.add(subCodice);                        
  546.                             //throw new Exception("Found signature part("+ reference+") not expected");
  547.                         }
  548.                     }
  549.                 }
  550.             }
  551.             
  552.             return notResolvedMap;
  553.             
  554.         }catch(Exception e){
  555.             throw new SecurityException(e.getMessage(),e);
  556.         }
  557.     }
  558.     
  559. }
Created with JaCoCo 0.8.8.202204050719