MessageSecuritySender_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;


  25. import java.util.ArrayList;
  26. import java.util.HashMap;
  27. import java.util.Iterator;
  28. import java.util.List;
  29. import java.util.Map;

  31. import javax.xml.soap.AttachmentPart;
  32. import javax.xml.soap.SOAPPart;
  33. import javax.xml.transform.dom.DOMSource;

  35. import org.adroitlogic.soapbox.MessageSecurityContext;
  36. import org.adroitlogic.soapbox.SecurityRequest;
  37. import org.adroitlogic.ultraesb.core.MessageImpl;
  38. import org.openspcoop2.message.OpenSPCoop2Message;
  39. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  40. import org.openspcoop2.message.constants.ServiceBinding;
  41. import org.openspcoop2.message.xml.MessageXMLUtils;
  42. import org.openspcoop2.security.SecurityException;
  43. import org.openspcoop2.security.message.IMessageSecuritySender;
  44. import org.openspcoop2.security.message.constants.SecurityConstants;
  45. import org.openspcoop2.security.message.utils.AttachmentProcessingPart;
  46. import org.openspcoop2.security.message.utils.ElementProcessingPart;
  47. import org.openspcoop2.security.message.utils.EncryptionBean;
  48. import org.openspcoop2.security.message.utils.KeystoreUtils;
  49. import org.openspcoop2.security.message.utils.ProcessingPart;
  50. import org.openspcoop2.security.message.utils.ProcessingPartUtils;
  51. import org.openspcoop2.security.message.utils.SignatureBean;
  52. import org.openspcoop2.utils.Utilities;
  53. import org.openspcoop2.utils.certificate.KeyStore;
  54. import org.openspcoop2.utils.resources.ClassLoaderUtilities;
  55. import org.openspcoop2.utils.xml.AbstractXMLUtils;
  56. import org.w3c.dom.Document;

  58. /**
  59.  * WSSContext_soapbox
  60.  *
  61.  * @author Andrea Poli (apoli@link.it)
  62.  * @author Giovanni Bussu (bussu@link.it)
  63.  * @author $Author$
  64.  * @version $Rev$, $Date$
  65.  */
  66. public class MessageSecuritySender_soapbox implements IMessageSecuritySender{

  68.     
  69.     @Override
  70.     public void process(org.openspcoop2.security.message.MessageSecurityContext messageSecurityContext,OpenSPCoop2Message messageParam, org.openspcoop2.utils.Map<Object> ctx) throws SecurityException{
  71.         try{    

  73.             if(ServiceBinding.SOAP.equals(messageParam.getServiceBinding())==false){
  74.                 throw new SecurityException("SoapBox Engine usable only with SOAP Binding");
  75.             }
  76.             OpenSPCoop2SoapMessage message = messageParam.castAsSoap();
  77.             AbstractXMLUtils xmlUtils = MessageXMLUtils.getInstance(message.getFactory());
  78.             



  82.             // ********** Leggo operazioni ***************
  83.             boolean encrypt = false;
  84.             boolean signature = false;
  85.             boolean timestamp = false;

  87.             String[]actions = ((String)messageSecurityContext.getOutgoingProperties().get(SecurityConstants.ACTION)).split(" ");
  88.             for (int i = 0; i < actions.length; i++) {
  89.                 if(SecurityConstants.isActionEncryption(actions[i].trim())){
  90.                     encrypt = true;
  91.                 }
  92.                 else if(SecurityConstants.SIGNATURE_ACTION.equals(actions[i].trim())){
  93.                     signature = true;
  94.                 }
  95.                 else if(SecurityConstants.TIMESTAMP_ACTION.equals(actions[i].trim())){
  96.                     timestamp = true;
  97.                 }
  98.             }
  99.             
  100.             //rilasciato vincolo di abilitazione signature o encryption per abilitare il timestamp
  101. //          if(!signature && !encrypt && timestamp){
  102. //              throw new WSSException("La funzionalita' "+WSSConstants.TIMESTAMP_ACTION+" richiede per essere abilitata almeno una delle seguenti altre funzionalita': "+
  103. //                      WSSConstants.ENCRYPT_ACTION+","+WSSConstants.SIGNATURE_ACTION);
  104. //          }
  105.             




  110.             // ********** Inizializzo Header WSS ***************

  112.             SOAPPart sp = message.getSOAPPart();
  113.             //Document d = sp;
  114.             Document d = sp.getDocumentElement().getOwnerDocument();
  115.             MessageSecurityContext msgSecCtx = new MessageSecurityContext(d, new MessageImpl(true, null, "http"));
  116.             Object mustUnderstandObject = messageSecurityContext.getOutgoingProperties().get(SecurityConstants.MUST_UNDERSTAND);
  117.             boolean mustUnderstand = false;
  118.             if(mustUnderstandObject!=null){
  119.                 mustUnderstand = SecurityConstants.TRUE.equals(mustUnderstandObject);
  120.             }
  121.             WSSUtils.initWSSecurityHeader(message,messageSecurityContext.getActor(),mustUnderstand);


  124.             
  125.             
  126.             
  127.             
  128.             
  129.             // **************** Inizializzo process per timestamp **************************
  130.             
  131.             TimestampMessageProcessor timestampProc = null;
  132.             if(timestamp){
  133.                 timestampProc = new TimestampMessageProcessor();
  134.             }
  135.             
  136.             
  137.             
  138.             
  139.             

  141.             // **************** Inizializzo process per cifrare **************************

  143.             EncryptPartialMessageProcessor encMsgProc = null;
  144.             if(encrypt){
  145.                 encMsgProc = new EncryptPartialMessageProcessor();
  146.                 encMsgProc.setMessage(message);
  147.                 encMsgProc.setActor(messageSecurityContext.getActor());
  148.                 encMsgProc.setMustUnderstand(mustUnderstand);

  150.                 // encryptionParts
  151.                 Object encryptionParts =  messageSecurityContext.getOutgoingProperties().get(SecurityConstants.ENCRYPTION_PARTS);
  152.                 List<ProcessingPart<?,?>> lstEncryptionParts = null;

  154.                 if(encryptionParts!=null){
  155.                     lstEncryptionParts = ProcessingPartUtils.getEncryptionInstance().getProcessingParts((String)encryptionParts);
  156.                 }

  158.                 boolean allPresente = false;
  159.                 boolean allComplete = false;
  160.                 List<AttachmentProcessingPart> lstAttachments = new ArrayList<AttachmentProcessingPart>();
  161.                 
  162.                 if(lstEncryptionParts!=null) {
  163.                     for(ProcessingPart<?,?> part: lstEncryptionParts) {
  164.     
  165.                         if(part instanceof AttachmentProcessingPart) {
  166.                             AttachmentProcessingPart attProcessingPart = (AttachmentProcessingPart) part;
  167.                             if(attProcessingPart.isAllAttachments()) {
  168.                                 allPresente = true;
  169.                                 allComplete = !attProcessingPart.isContent();
  170.                             } else {
  171.                                 lstAttachments.add(attProcessingPart);
  172.                             }
  173.                             
  174.     
  175.                         } else if(part instanceof ElementProcessingPart) {  
  176.                             ElementProcessingPart elProcessingPart = (ElementProcessingPart) part;
  177.                             encMsgProc.addElementToEncrypt(elProcessingPart.getPart(),elProcessingPart.isContent());
  178.                         }
  179.                     }
  180.                 }
  181.                 
  182.                 if(allPresente || lstAttachments.size()>0){
  183.                     
  184.                     Iterator<?> it = message.getAttachments();
  185.                     
  186.                     if(it.hasNext()==false){
  187.                         throw new Exception("Property "+SecurityConstants.ENCRYPTION_PARTS+ " contiene la richiesta di cifrare attachments, ma il messaggio non ne contiene");
  188.                     }
  189.                 
  190.                     int indexAllegatoEncrypt = 1;
  191.                     while (it.hasNext()) {
  192.                         AttachmentPart ap = (AttachmentPart) it.next();
  193.                         if(allPresente){
  194.                             encMsgProc.addAttachmentToEncrypt(ap, !allComplete);
  195.                         }else{
  196.                             boolean found = false;
  197.                             for (int i = 0; i < lstAttachments.size() && !found; i++) {
  198.                                 if(lstAttachments.get(i).getPart().equals(indexAllegatoEncrypt)) {
  199.                                     encMsgProc.addAttachmentToEncrypt(ap, !lstAttachments.get(i).isContent());
  200.                                     found = true;
  201.                                 }
  202.                             }
  203.                             indexAllegatoEncrypt++;
  204.                         }
  205.                     }
  206.                     
  207.                 }

  209.             }
  210.         
  211.             





  217.             // **************** Inizializzo process per firmare **************************
  218.             
  219.             SignPartialMessageProcessor signMsgProc = null;
  220.             if(signature){
  221.                 signMsgProc = (SignPartialMessageProcessor) ClassLoaderUtilities.newInstance(message.getSignPartialMessageProcessorClass());
  222.                 signMsgProc.setMessage(message);
  223.                 signMsgProc.setActor(messageSecurityContext.getActor());
  224.                 signMsgProc.setMustUnderstand(mustUnderstand);

  226.                 // encryptionParts
  227.                 Object signatureParts =  messageSecurityContext.getOutgoingProperties().get(SecurityConstants.SIGNATURE_PARTS);
  228.                 List<ProcessingPart<?,?>> lstSignatureParts = null;

  230.                 if(signatureParts!=null){
  231.                     lstSignatureParts = ProcessingPartUtils.getSignatureInstance().getProcessingParts((String)signatureParts);
  232.                 }

  234.                 boolean allPresente = false;
  235.                 boolean allComplete = false;
  236.                 List<AttachmentProcessingPart> lstAttachments = new ArrayList<AttachmentProcessingPart>();
  237.                 
  238.                 if(lstSignatureParts!=null) {
  239.                     for(ProcessingPart<?,?> part: lstSignatureParts) {
  240.     
  241.                         if(part instanceof AttachmentProcessingPart) {
  242.                             AttachmentProcessingPart attProcessingPart = (AttachmentProcessingPart) part;
  243.                             if(attProcessingPart.isAllAttachments()) {
  244.                                 allPresente = true;
  245.                                 allComplete = !attProcessingPart.isContent();
  246.                             } else {
  247.                                 lstAttachments.add(attProcessingPart);
  248.                             }
  249.                             
  250.     
  251.                         } else if(part instanceof ElementProcessingPart) {  
  252.                             ElementProcessingPart elProcessingPart = (ElementProcessingPart) part;
  253.                             signMsgProc.addElementToSign(elProcessingPart.getPart(),elProcessingPart.isContent());
  254.                         }
  255.                     }
  256.                 }
  257.                 
  258.                 if(allPresente || lstAttachments.size()>0){
  259.                     
  260.                     Iterator<?> it = message.getAttachments();
  261.                     
  262.                     if(it.hasNext()==false){
  263.                         throw new Exception("Property "+SecurityConstants.SIGNATURE_PARTS+ " contiene la richiesta di cifrare attachments, ma il messaggio non ne contiene");
  264.                     }
  265.                 
  266.                     int indexAllegatoEncrypt = 1;
  267.                     while (it.hasNext()) {
  268.                         AttachmentPart ap = (AttachmentPart) it.next();
  269.                         if(allPresente){
  270.                             signMsgProc.addAttachmentsToSign(ap, !allComplete);
  271.                         }else{
  272.                             boolean found = false;
  273.                             for (int i = 0; i < lstAttachments.size() && !found; i++) {
  274.                                 if(lstAttachments.get(i).getPart().equals(indexAllegatoEncrypt)) {
  275.                                     signMsgProc.addAttachmentsToSign(ap, !lstAttachments.get(i).isContent());
  276.                                     found = true;
  277.                                 }
  278.                             }
  279.                             indexAllegatoEncrypt++;
  280.                         }
  281.                     }
  282.                     
  283.                 }

  285.             }
  286.         
  287.             




  292.             // **************** Leggo parametri encryption store **************************
  293.             KeyStore encryptionKS = null;
  294.             KeyStore encryptionTrustStoreKS = null;
  295.             boolean encryptionSymmetric = false;
  296.             String aliasEncryptUser = null;
  297.             String aliasEncryptPassword = null;
  298.             if(encrypt){
  299.                 
  300.                 EncryptionBean bean = KeystoreUtils.getSenderEncryptionBean(messageSecurityContext, ctx);
  301.                 
  302.                 encryptionKS = bean.getKeystore();
  303.                 encryptionTrustStoreKS = bean.getTruststore();
  304.                 encryptionSymmetric = bean.isEncryptionSimmetric();
  305.                 aliasEncryptUser = bean.getUser();
  306.                 aliasEncryptPassword = bean.getPassword();

  308.             }







  316.             // **************** Leggo parametri signature store **************************
  317.             KeyStore signatureKS = null;
  318.             KeyStore signatureTrustStoreKS = null;
  319.             String aliasSignatureUser = null;
  320.             String aliasSignaturePassword = null;
  321.             if(signature){
  322.             
  323.                 SignatureBean bean = KeystoreUtils.getSenderSignatureBean(messageSecurityContext, ctx);
  324.                 
  325.                 signatureKS = bean.getKeystore();
  326.                 signatureTrustStoreKS = bean.getTruststore();
  327.                 aliasSignatureUser = bean.getUser();
  328.                 aliasSignaturePassword = bean.getPassword();

  330.             }
  331.              

  333.             
  334.             
  335.             
  336.             
  337.             
  338.             
  339.             // **************** Inizializzo Context for timestamp **************************
  340.             
  341.             if(timestamp){
  342.                 Object ttlObject = messageSecurityContext.getOutgoingProperties().get(SecurityConstants.TIMESTAMP_TTL);
  343.                 if(ttlObject==null){
  344.                     ttlObject = SecurityConstants.TIMESTAMP_SOAPBOX_TTL_DEFAULT;
  345.                 }
  346.                 String ttl = (String) ttlObject; 
  347.                 long ttlLong = -1;
  348.                 try{
  349.                     ttlLong = Long.parseLong(ttl);
  350.                 }catch(Exception e){
  351.                     throw new Exception("Indicazione "+SecurityConstants.TIMESTAMP_TTL+" non corretta: "+e.getMessage());
  352.                 }
  353.                 msgSecCtx.getTimestampRequest().setTimeForExpiryMillis(ttlLong*1000l); // secondi
  354.                 
  355.                 //precision in milliseconds in Timestamp handling
  356.                 Object precisionObject = messageSecurityContext.getOutgoingProperties().get(SecurityConstants.TIMESTAMP_PRECISION);
  357.                 if(precisionObject==null){
  358.                     precisionObject = SecurityConstants.TRUE;
  359.                 }
  360.                 String precision = (String) precisionObject; 
  361.                 boolean precisionBoolean;
  362.                 try{
  363.                     precisionBoolean = Boolean.parseBoolean(precision);
  364.                 }catch(Exception e){
  365.                     throw new Exception("Indicazione "+SecurityConstants.TIMESTAMP_PRECISION+" non corretta: "+e.getMessage());
  366.                 }

  368.                 msgSecCtx.setProperty(SecurityConstants.TIMESTAMP_PRECISION, precisionBoolean);

  370.             }
  371.             
  372.             
  373.             
  374.             



  378.             // **************** Inizializzo Secure Context for encryption **************************
  379.             
  380.             org.openspcoop2.security.message.soapbox.SoapBoxSecurityConfig securityConfig_encryption = null;
  381.             if(encrypt){
  382.                 updateSecurityContextForEncryption(msgSecCtx, messageSecurityContext.getOutgoingProperties(), aliasEncryptUser);
  383.                 
  384.                 Map<String, String> passwordMap_encryption = new HashMap<>();
  385.                 passwordMap_encryption.put(aliasEncryptUser, aliasEncryptPassword);

  387.                 if(encryptionTrustStoreKS==null){
  388.                     encryptionTrustStoreKS = encryptionKS;
  389.                 }
  390.                 securityConfig_encryption = new org.openspcoop2.security.message.soapbox.SoapBoxSecurityConfig(encryptionKS, encryptionTrustStoreKS, passwordMap_encryption,ctx);
  391.                 securityConfig_encryption.setSymmetricSharedKey(encryptionSymmetric);
  392.             }










  403.             // **************** Inizializzo Secure Context for signature **************************
  404.             org.openspcoop2.security.message.soapbox.SoapBoxSecurityConfig securityConfig_signature = null;
  405.             if(signature){
  406.                 
  407.                 updateSecurityContextForSignature(msgSecCtx, messageSecurityContext.getOutgoingProperties(), aliasSignatureUser);
  408.                                 
  409.                 Map<String, String> passwordMap_signature = new HashMap<>();
  410.                 passwordMap_signature.put(aliasSignatureUser, aliasSignaturePassword);

  412.                 if(signatureTrustStoreKS==null){
  413.                     signatureTrustStoreKS = signatureKS;
  414.                 }
  415.                 securityConfig_signature = new org.openspcoop2.security.message.soapbox.SoapBoxSecurityConfig(signatureKS, signatureTrustStoreKS, passwordMap_signature,ctx);
  416.             }               
  417.             








  426.             // **************** Process **************************

  428.             // Devo rileggerle per eseguire nell'ordine
  429.             actions = ((String)messageSecurityContext.getOutgoingProperties().get(SecurityConstants.ACTION)).split(" ");
  430.             boolean actionSignatureOrEncryptDo = false;
  431.             for (int i = 0; i < actions.length; i++) {
  432.                 if(SecurityConstants.isActionEncryption(actions[i].trim())){
  433.                     if(actionSignatureOrEncryptDo){
  434.                         // Refresh serve anche per la encrypt ??
  435.                         //byte[]xmlCifrato=this.xmlUtils.toByteArray(msgSecCtx.getDocument().getDocumentElement());
  436.                         //message.getSOAPPart().setContent(new DOMSource(this.xmlUtils.newElement(xmlCifrato)));
  437.                         //signMsgProc.setMessage(message);
  438.                         //Document dUpdated = message.getSOAPPart().getDocumentElement().getOwnerDocument();
  439.                         //msgSecCtx = new MessageSecurityContext(dUpdated, new MessageImpl(true, null, "http"));
  440.                         //updateSecurityContextForEncryption(msgSecCtx, messageSecurityContext.getOutgoingProperties(), aliasEncryptUser);
  441.                     }
  442.                     encMsgProc.process(securityConfig_encryption, msgSecCtx);
  443.                     actionSignatureOrEncryptDo = true;
  444.                 }
  445.                 else if(SecurityConstants.SIGNATURE_ACTION.equals(actions[i].trim())){
  446.                     if(signMsgProc!=null) {
  447.                         if(actionSignatureOrEncryptDo){
  448.                             byte[]xmlCifrato=xmlUtils.toByteArray(msgSecCtx.getDocument().getDocumentElement());
  449.                             message.getSOAPPart().setContent(new DOMSource(xmlUtils.newElement(xmlCifrato)));
  450.                             signMsgProc.setMessage(message);
  451.                             Document dUpdated = message.getSOAPPart().getDocumentElement().getOwnerDocument();
  452.                             msgSecCtx = new MessageSecurityContext(dUpdated, new MessageImpl(true, null, "http"));
  453.                             updateSecurityContextForSignature(msgSecCtx, messageSecurityContext.getOutgoingProperties(), aliasSignatureUser);
  454.                         }
  455.                         signMsgProc.process(securityConfig_signature, msgSecCtx);
  456.                         actionSignatureOrEncryptDo = true;
  457.                     }
  458.                 }
  459.                 else if(SecurityConstants.TIMESTAMP_ACTION.equals(actions[i].trim())){
  460.                     if(timestampProc!=null) {
  461.                         if(securityConfig_signature!=null){
  462.                             timestampProc.process(securityConfig_signature,msgSecCtx);
  463.                         }
  464.                         else if(securityConfig_encryption!=null){
  465.                             timestampProc.process(securityConfig_encryption,msgSecCtx);
  466.                         } else {
  467.                             timestampProc.process(null,msgSecCtx);
  468.                         }
  469.                     }
  470.                 }
  471.             }




  476.         }
  477.         catch(Exception e){
  478.             
  479.             String msg = Utilities.getInnerNotEmptyMessageException(e).getMessage();
  480.             
  481.             Throwable innerExc = Utilities.getLastInnerException(e);
  482.             String innerMsg = null;
  483.             if(innerExc!=null){
  484.                 innerMsg = innerExc.getMessage();
  485.             }
  486.             
  487.             String messaggio = null;
  488.             if(msg!=null){
  489.                 messaggio = new String(msg);
  490.                 if(innerMsg!=null && !innerMsg.equals(msg)){
  491.                     messaggio = messaggio + " ; " + innerMsg;
  492.                 }
  493.             }
  494.             else{
  495.                 if(innerMsg!=null){
  496.                     messaggio = innerMsg;
  497.                 }
  498.             }
  499.             
  500.             // L'if scopre l'eventuale motivo preciso riguardo al fallimento della cifratura/firma.
  501.             if(Utilities.existsInnerException(e, org.adroitlogic.soapbox.ElementNotFoundException.class)){
  502.                 Throwable t = Utilities.getLastInnerException(e);
  503.                 if(t instanceof org.adroitlogic.soapbox.ElementNotFoundException){
  504.                     String notFoundMessage = t.getMessage();
  505.                     messaggio = t.getMessage().substring(0, notFoundMessage.indexOf("not found as a child of"));
  506.                     messaggio = messaggio + "not found as a child of SoapEnvelope";
  507.                 }
  508.             }
  509.             
  510.             SecurityException wssException = new SecurityException(e.getMessage(), e);
  511.             wssException.setMsgErrore(messaggio);
  512.             throw wssException;

  514.         }

  516.     }


  519.     
  520.     private void updateSecurityContextForSignature(MessageSecurityContext msgSecCtx, Map<String, Object> outProps, String aliasSignatureUser) throws Exception {
  521.         
  522.         Object c14nAlgoURI = outProps.get(SecurityConstants.SIGNATURE_C14N_ALGORITHM);
  523.         Object digestAlgoURI = outProps.get(SecurityConstants.SIGNATURE_DIGEST_ALGORITHM);
  524.         Object signatureAlgoURI = outProps.get(SecurityConstants.SIGNATURE_ALGORITHM);
  525.         Object wsiBPCompliant = outProps.get(SecurityConstants.IS_BSP_COMPLIANT);
  526.         Object signatureKeyIdentifier = outProps.get(SecurityConstants.SIGNATURE_KEY_IDENTIFIER);

  528.         if(c14nAlgoURI!=null){
  529.             msgSecCtx.getSignatureRequest().setC14nAlgoURI((String)c14nAlgoURI);
  530.         }
  531.         if(digestAlgoURI!=null){
  532.             msgSecCtx.getSignatureRequest().setDigestAlgoURI((String)digestAlgoURI);
  533.         }
  534.         if(wsiBPCompliant!=null){
  535.             try{
  536.                 msgSecCtx.getSignatureRequest().setWsiBPCompliant(Boolean.parseBoolean((String)wsiBPCompliant));
  537.             }catch(Exception e){
  538.                 throw new Exception(SecurityConstants.IS_BSP_COMPLIANT+" con valore non valido (atteso true/false): ["+wsiBPCompliant+"]");
  539.             }
  540.         }else{
  541.             msgSecCtx.getSignatureRequest().setWsiBPCompliant(true);
  542.         }
  543.         if(signatureAlgoURI!=null){
  544.             msgSecCtx.getSignatureRequest().setSignatureAlgoURI((String)signatureAlgoURI);
  545.         }else{
  546.             throw new Exception(SecurityConstants.SIGNATURE_ALGORITHM+" non fornito");
  547.         }
  548.         if(signatureKeyIdentifier!=null){
  549.             if(SecurityConstants.KEY_IDENTIFIER_BST_DIRECT_REFERENCE.equals(signatureKeyIdentifier)){
  550.                 msgSecCtx.getSignatureRequest().setKeyIdentifierType(SecurityRequest.KeyIdentifierType.BST_DIRECT_REFERENCE);       
  551.             }
  552.             else if(SecurityConstants.KEY_IDENTIFIER_ISSUER_SERIAL.equals(signatureKeyIdentifier)){
  553.                 msgSecCtx.getSignatureRequest().setKeyIdentifierType(SecurityRequest.KeyIdentifierType.ISSUER_SERIAL);      
  554.             }
  555.             else if(SecurityConstants.KEY_IDENTIFIER_SKI.equals(signatureKeyIdentifier)){
  556.                 msgSecCtx.getSignatureRequest().setKeyIdentifierType(SecurityRequest.KeyIdentifierType.SKI_KEY_IDENTIFIER);     
  557.             }
  558.             else if(SecurityConstants.KEY_IDENTIFIER_THUMBPRINT.equals(signatureKeyIdentifier)){
  559.                 msgSecCtx.getSignatureRequest().setKeyIdentifierType(SecurityRequest.KeyIdentifierType.THUMBPRINT_IDENTIFIER);      
  560.             }
  561.             else if(SecurityConstants.KEY_IDENTIFIER_X509.equals(signatureKeyIdentifier)){
  562.                 msgSecCtx.getSignatureRequest().setKeyIdentifierType(SecurityRequest.KeyIdentifierType.X509_KEY_IDENTIFIER);        
  563.             }
  564.             else{
  565.                 throw new Exception(SecurityConstants.SIGNATURE_KEY_IDENTIFIER+" not supported ["+signatureKeyIdentifier+"]");
  566.             }
  567.         }else{
  568.             // default: BST
  569.             msgSecCtx.getSignatureRequest().setKeyIdentifierType(SecurityRequest.KeyIdentifierType.BST_DIRECT_REFERENCE);   
  570.         }
  571.         msgSecCtx.getSignatureRequest().setCertAlias(aliasSignatureUser);
  572.     }
  573.     
  574.     private void updateSecurityContextForEncryption(MessageSecurityContext msgSecCtx, Map<String, Object> outProps, String aliasEncryptUser) throws Exception {
  575.         
  576.         Object encryptionKeySizeObject = outProps.get(SecurityConstants.ENCRYPTION_KEY_SIZE);
  577.         int encryptionKeySize = -1;
  578.         if(encryptionKeySizeObject!=null){
  579.             encryptionKeySize = Integer.parseInt((String)encryptionKeySizeObject);
  580.         }

  582.         Object encryptionSymmetricAlgoritm = outProps.get(SecurityConstants.ENCRYPTION_SYMMETRIC_ALGORITHM);
  583.         Object encryptionKeyTransport = outProps.get(SecurityConstants.ENCRYPTION_KEY_TRANSPORT_ALGORITHM);
  584.         
  585.         if(encryptionKeySize>0){
  586.             msgSecCtx.getEncryptionRequest().setKeySize(encryptionKeySize);
  587.         }
  588.         if(encryptionSymmetricAlgoritm!=null){
  589.             msgSecCtx.getEncryptionRequest().setSymmetricKeyAlgoURI((String)encryptionSymmetricAlgoritm);
  590.         }
  591.         if(encryptionKeyTransport!=null){
  592.             msgSecCtx.getEncryptionRequest().setEncryptionAlgoURI((String)encryptionKeyTransport);
  593.         }
  594.         Object encryptionKeyIdentifier = outProps.get(SecurityConstants.ENCRYPTION_KEY_IDENTIFIER);
  595.         if(encryptionKeyIdentifier!=null){
  596.             if(SecurityConstants.KEY_IDENTIFIER_BST_DIRECT_REFERENCE.equals(encryptionKeyIdentifier)){
  597.                 msgSecCtx.getEncryptionRequest().setKeyIdentifierType(SecurityRequest.KeyIdentifierType.BST_DIRECT_REFERENCE);      
  598.             }
  599.             else if(SecurityConstants.KEY_IDENTIFIER_ISSUER_SERIAL.equals(encryptionKeyIdentifier)){
  600.                 msgSecCtx.getEncryptionRequest().setKeyIdentifierType(SecurityRequest.KeyIdentifierType.ISSUER_SERIAL);     
  601.             }
  602.             else if(SecurityConstants.KEY_IDENTIFIER_SKI.equals(encryptionKeyIdentifier)){
  603.                 msgSecCtx.getEncryptionRequest().setKeyIdentifierType(SecurityRequest.KeyIdentifierType.SKI_KEY_IDENTIFIER);        
  604.             }
  605.             else if(SecurityConstants.KEY_IDENTIFIER_THUMBPRINT.equals(encryptionKeyIdentifier)){
  606.                 msgSecCtx.getEncryptionRequest().setKeyIdentifierType(SecurityRequest.KeyIdentifierType.THUMBPRINT_IDENTIFIER);     
  607.             }
  608.             else if(SecurityConstants.KEY_IDENTIFIER_X509.equals(encryptionKeyIdentifier)){
  609.                 msgSecCtx.getEncryptionRequest().setKeyIdentifierType(SecurityRequest.KeyIdentifierType.X509_KEY_IDENTIFIER);       
  610.             }
  611.             else{
  612.                 throw new Exception(SecurityConstants.ENCRYPTION_KEY_IDENTIFIER+" not supported ["+encryptionKeyIdentifier+"]");
  613.             }
  614.         }else{
  615.             // default: BST
  616.             msgSecCtx.getEncryptionRequest().setKeyIdentifierType(SecurityRequest.KeyIdentifierType.BST_DIRECT_REFERENCE);  
  617.         }
  618.         
  619.         msgSecCtx.getEncryptionRequest().setCertAlias(aliasEncryptUser);
  620.     }
  621. }




Created with JaCoCo 0.8.8.202204050719