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



  23. package org.openspcoop2.security.message;

  25. import java.io.IOException;
  26. import java.security.KeyStore;
  27. import java.util.ArrayList;
  28. import java.util.HashMap;
  29. import java.util.Iterator;
  30. import java.util.List;
  31. import java.util.Map;
  32. import java.util.Properties;

  34. import javax.security.auth.callback.Callback;
  35. import javax.security.auth.callback.CallbackHandler;
  36. import javax.security.auth.callback.UnsupportedCallbackException;
  37. import javax.xml.soap.SOAPElement;
  38. import javax.xml.soap.SOAPEnvelope;
  39. import javax.xml.soap.SOAPHeader;
  40. import javax.xml.soap.SOAPHeaderElement;
  41. import javax.xml.soap.SOAPPart;

  43. import org.apache.wss4j.common.ConfigurationConstants;
  44. import org.apache.wss4j.common.ext.WSPasswordCallback;
  45. import org.openspcoop2.core.commons.DBUtils;
  46. import org.openspcoop2.core.id.IDServizio;
  47. import org.openspcoop2.core.id.IDSoggetto;
  48. import org.openspcoop2.core.mvc.properties.utils.DBPropertiesUtils;
  49. import org.openspcoop2.core.mvc.properties.utils.MultiPropertiesUtilities;
  50. import org.openspcoop2.core.transazioni.utils.TempiElaborazione;
  51. import org.openspcoop2.message.MessageUtils;
  52. import org.openspcoop2.message.OpenSPCoop2Message;
  53. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  54. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  55. import org.openspcoop2.message.constants.MessageRole;
  56. import org.openspcoop2.message.constants.MessageType;
  57. import org.openspcoop2.message.constants.ServiceBinding;
  58. import org.openspcoop2.message.soap.SoapUtils;
  59. import org.openspcoop2.message.soap.reference.Reference;
  60. import org.openspcoop2.message.xml.XPathExpressionEngine;
  61. import org.openspcoop2.protocol.sdk.Busta;
  62. import org.openspcoop2.protocol.sdk.constants.CodiceErroreCooperazione;
  63. import org.openspcoop2.security.SecurityException;
  64. import org.openspcoop2.security.keystore.KeystoreConstants;
  65. import org.openspcoop2.security.message.constants.SecurityConstants;
  66. import org.openspcoop2.security.message.saml.SAMLConstants;
  67. import org.openspcoop2.security.message.utils.EncryptionBean;
  68. import org.openspcoop2.security.message.utils.SignatureBean;
  69. import org.openspcoop2.utils.LoggerWrapperFactory;
  70. import org.openspcoop2.utils.certificate.KeystoreType;
  71. import org.openspcoop2.utils.digest.IDigestReader;
  72. import org.openspcoop2.utils.properties.PropertiesUtilities;
  73. import org.openspcoop2.utils.resources.ClassLoaderUtilities;
  74. import org.openspcoop2.utils.xml.AbstractXPathExpressionEngine;
  75. import org.openspcoop2.utils.xml.DynamicNamespaceContext;
  76. import org.openspcoop2.utils.xml.XPathNotFoundException;
  77. import org.openspcoop2.utils.xml.XPathReturnType;
  78. import org.slf4j.Logger;

  80. /**
  81.  * Classe di base per la gestione della sicurezza
  82.  *
  83.  * @author Spadafora Marcello (Ma.Spadafora@finsiel.it)
  84.  * @author $Author$
  85.  * @version $Rev$, $Date$
  86.  */

  88. public abstract class MessageSecurityContext{
  89.     
  90.       
  91.     protected Map<String,Object> incomingProperties = new HashMap<>();
  92.     protected Map<String,Object> outgoingProperties = new HashMap<>();

  94.     protected boolean useActorDefaultIfNotDefined = true;
  95.     protected String actorDefault = null;
  96.     protected String actor;

  98.     protected String msgErrore;
  99.     protected CodiceErroreCooperazione codiceErrore;
  100.     /** Eventuale subCodici di errore */
  101.     protected List<SubErrorCodeSecurity> listaSubCodiceErrore = new ArrayList<>();
  102.         
  103.     protected boolean functionAsClient = true;
  104.     
  105.     protected String prefixWsuId;
  106.     
  107.     protected boolean removeAllWsuIdRef;
  108.     
  109.     protected String securityEngine;
  110.     protected IMessageSecurityContext messageSecurityContext;
  111.     protected IMessageSecuritySender messageSecuritySender;
  112.     protected IMessageSecurityReceiver messageSecurityReceiver;
  113.     protected IMessageSecurityDigest messageSecurityDigest;
  114.     
  115.     protected Logger log;
  116.     public Logger getLog() {
  117.         return this.log;
  118.     }

  120.     private IDSoggetto idFruitore;
  121.     private String pddFruitore;
  122.     private IDServizio idServizio;
  123.     private String pddErogatore;
  124.     public IDSoggetto getIdFruitore() {
  125.         return this.idFruitore;
  126.     }
  127.     public IDServizio getIdServizio() {
  128.         return this.idServizio;
  129.     }
  130.     public String getPddFruitore() {
  131.         return this.pddFruitore;
  132.     }
  133.     public String getPddErogatore() {
  134.         return this.pddErogatore;
  135.     }
  136.     
  137.     private List<Reference> references;
  138.     public List<Reference> getReferences() {
  139.         return this.references;
  140.     }
  141.     public void setReferences(List<Reference> references) {
  142.         this.references = references;
  143.     }
  144.     
  145.     
  146.     // I due encrypt part servono per un utilizzo manuale delle classi di sicurezza
  147.     
  148.     private String manualAttachmentsEncryptPart = null;
  149.     private String manualAttachmentsSignaturePart = null;
  150.     
  151.     public String getManualAttachmentsEncryptPart() {
  152.         return this.manualAttachmentsEncryptPart;
  153.     }
  154.     public void setManualAttachmentsEncryptPart(String manualAttachmentsEncryptPart) {
  155.         this.manualAttachmentsEncryptPart = manualAttachmentsEncryptPart;
  156.     }
  157.     public String getManualAttachmentsSignaturePart() {
  158.         return this.manualAttachmentsSignaturePart;
  159.     }
  160.     public void setManualAttachmentsSignaturePart(String manualAttachmentsSignaturePart) {
  161.         this.manualAttachmentsSignaturePart = manualAttachmentsSignaturePart;
  162.     }
  163.     
  164.     // I due bean signatureBean e encryptionBean servono per un utilizzo manuale delle classi di sicurezza.
  165.     
  166.     private SignatureBean signatureBean;
  167.     private EncryptionBean encryptionBean;
  168.     public SignatureBean getSignatureBean() {
  169.         return this.signatureBean;
  170.     }
  171.     public void setSignatureBean(SignatureBean signatureBean) {
  172.         this.signatureBean = signatureBean;
  173.     }
  174.     public EncryptionBean getEncryptionBean() {
  175.         return this.encryptionBean;
  176.     }
  177.     public void setEncryptionBean(EncryptionBean encryptionBean) {
  178.         this.encryptionBean = encryptionBean;
  179.     }
  180.     
  181.     /**
  182.      * Costruttore. 
  183.      * 
  184.      * @param messageSecurityContextParameters contextParameters
  185.      */
  186.     protected MessageSecurityContext(MessageSecurityContextParameters messageSecurityContextParameters){
  187.         this.useActorDefaultIfNotDefined = messageSecurityContextParameters.isUseActorDefaultIfNotDefined();
  188.         this.actorDefault = messageSecurityContextParameters.getActorDefault();
  189.         if(messageSecurityContextParameters.getLog()!=null)
  190.             this.log = messageSecurityContextParameters.getLog();
  191.         else
  192.             this.log = LoggerWrapperFactory.getLogger(MessageSecurityContext.class);
  193.         this.functionAsClient = messageSecurityContextParameters.isFunctionAsClient();
  194.         this.prefixWsuId = messageSecurityContextParameters.getPrefixWsuId();
  195.         this.removeAllWsuIdRef = messageSecurityContextParameters.isRemoveAllWsuIdRef();
  196.         this.idFruitore = messageSecurityContextParameters.getIdFruitore();
  197.         this.idServizio = messageSecurityContextParameters.getIdServizio();
  198.         this.pddFruitore = messageSecurityContextParameters.getPddFruitore();
  199.         this.pddErogatore = messageSecurityContextParameters.getPddErogatore();
  200.     }
  201.     
  202.     
  203.     /** Process */
  204.     
  205.     // incoming
  206.     protected abstract boolean processIncoming(OpenSPCoop2Message message, Busta busta, org.openspcoop2.utils.Map<Object> ctx);
  207.     public boolean processIncoming(OpenSPCoop2Message message, Busta busta, org.openspcoop2.utils.Map<Object> ctx, TempiElaborazione tempiElaborazione) {
  208.         MessageRole messageRole = message.getMessageRole();
  209.         if(MessageRole.REQUEST.equals(messageRole)) {
  210.             if(tempiElaborazione!=null) {
  211.                 tempiElaborazione.startSicurezzaMessaggioRichiesta();
  212.             }
  213.         }
  214.         else {
  215.             if(tempiElaborazione!=null) {
  216.                 tempiElaborazione.startSicurezzaMessaggioRisposta();
  217.             }
  218.         }
  219.         try {
  220.             return this.processIncoming(message, busta, ctx);
  221.         }
  222.         finally {
  223.             if(MessageRole.REQUEST.equals(messageRole)) {
  224.                 if(tempiElaborazione!=null) {
  225.                     tempiElaborazione.endSicurezzaMessaggioRichiesta();
  226.                 }
  227.             }
  228.             else {
  229.                 if(tempiElaborazione!=null) {
  230.                     tempiElaborazione.endSicurezzaMessaggioRisposta();
  231.                 }
  232.             }
  233.         }
  234.     }

  236.     // outcoming
  237.     protected abstract boolean processOutgoing(OpenSPCoop2Message message, org.openspcoop2.utils.Map<Object> ctx);
  238.     public boolean processOutgoing(OpenSPCoop2Message message, org.openspcoop2.utils.Map<Object> ctx, TempiElaborazione tempiElaborazione) {
  239.         MessageRole messageRole = message.getMessageRole();
  240.         if(MessageRole.REQUEST.equals(messageRole)) {
  241.             if(tempiElaborazione!=null) {
  242.                 tempiElaborazione.startSicurezzaMessaggioRichiesta();
  243.             }
  244.         }
  245.         else {
  246.             if(tempiElaborazione!=null) {
  247.                 tempiElaborazione.startSicurezzaMessaggioRisposta();
  248.             }
  249.         }
  250.         try {
  251.             return this.processOutgoing(message, ctx);
  252.         }
  253.         finally {
  254.             if(MessageRole.REQUEST.equals(messageRole)) {
  255.                 if(tempiElaborazione!=null) {
  256.                     tempiElaborazione.endSicurezzaMessaggioRichiesta();
  257.                 }
  258.             }
  259.             else {
  260.                 if(tempiElaborazione!=null) {
  261.                     tempiElaborazione.endSicurezzaMessaggioRisposta();
  262.                 }
  263.             }
  264.         }
  265.     }
  266.     

  268.     /** Function As Client */
  269.     public void setFunctionAsClient(boolean functionAsClient) {
  270.         this.functionAsClient = functionAsClient;
  271.     }
  272.     public boolean isFunctionAsClient() {
  273.         return this.functionAsClient;
  274.     }
  275.     
  276.     
  277.     /** Prefix WSUID */
  278.     public String getPrefixWsuId() {
  279.         return this.prefixWsuId;
  280.     }
  281.     

  283.     /**  indicazione se rimuovere tutti gli attributi WsuId negli elementi 'toccati' dalla sicurezza */
  284.     public boolean isRemoveAllWsuIdRef() {
  285.         return this.removeAllWsuIdRef;
  286.     }
  287.     
  288.     
  289.     
  290.     /** GetValues ottenuti dopo il processamento */
  291.     public abstract String getSubject();
  292.     public String getMsgErrore() { return this.msgErrore; }
  293.     public CodiceErroreCooperazione getCodiceErrore() { return this.codiceErrore; }
  294.     public List<SubErrorCodeSecurity> getListaSubCodiceErrore() {
  295.         return this.listaSubCodiceErrore;
  296.     }

  298.     
  299.     
  300.     
  301.     /** Actor utilizzato nell'header di sicurezza */
  302.     /**
  303.      * Set/get dell'Actor
  304.      */
  305.     public String getActor() {
  306.         return this.actor;
  307.     }
  308.     private void setActor(boolean incoming) {
  309.         boolean actorDefinito = false;
  310.         boolean mustUnderstandTrue=false;
  311.         
  312.         Map<String,Object> securityProperties = null;
  313.         if(incoming){
  314.             securityProperties = this.incomingProperties;
  315.         }else{
  316.             securityProperties = this.outgoingProperties;
  317.         }
  318.         if (securityProperties != null && securityProperties.size() > 0) {
  319.             
  320.             for (String key : securityProperties.keySet()) {
  321.                 String value = null;
  322.                 Object oValue = securityProperties.get(key);
  323.                 if(oValue instanceof String) {
  324.                     value = (String) oValue;
  325.                 }
  326.                 
  327.                 /**System.out.println(key + " -> " + value );*/
  328.                 // check actor
  329.                 if(ConfigurationConstants.ACTOR.equals(key)){
  330.                     this.actor = value;
  331.                 }
  332.                 
  333.                 // Check Fix Bug#18 Test-1
  334.                 if(ConfigurationConstants.MUST_UNDERSTAND.equals(key)){
  335.                     if("true".equals(value)){
  336.                         mustUnderstandTrue = true;
  337.                     }
  338.                 }else if("actor".equals(key)){
  339.                     actorDefinito = true;
  340.                 }
  341.                 
  342.             }
  343.         }
  344.         if(mustUnderstandTrue && actorDefinito==false && this.useActorDefaultIfNotDefined ){
  345.             // Aggiungo actor 'govway'
  346.             this.actor = this.actorDefault;
  347.         }
  348.     }
  349.     
  350.     
  351.     
  352.     /** Security Message Properties */
  353.     /**
  354.      * Set/get  proprieta' che verranno usate per i messaggi in ingresso dal MessageSecurity
  355.      * @param secProperties
  356.      */
  357.     public void setIncomingProperties(Map<String,Object> secProperties) throws SecurityException{
  358.         this.setIncomingProperties(secProperties, true, false);
  359.     }
  360.     public void setIncomingProperties(Map<String,Object> secProperties, boolean convertSecProperties) throws SecurityException{
  361.         this.setIncomingProperties(secProperties, convertSecProperties, false);
  362.     }
  363.     public void setIncomingProperties(Map<String,Object> secProperties, boolean convertSecProperties, boolean preserveNotStringProperty) throws SecurityException{
  364.         if(secProperties!=null && secProperties.size()>0 && convertSecProperties) {
  365.             this.incomingProperties = convertSecProperties(secProperties, preserveNotStringProperty);
  366.         }
  367.         else {
  368.             this.incomingProperties = secProperties;
  369.         }
  370.         this.setActor(true);
  371.         this.readMessageSecurityEngine(true);
  372.         this.resolvePWCallback(true);
  373.     }
  374.     public Map<String,Object> getIncomingProperties() {
  375.         return this.incomingProperties;
  376.     }
  377.     /**
  378.      * Set/get  proprieta' che verranno usate per i messaggi in uscita dal MessageSecurity
  379.      * @param secProperties
  380.      */
  381.     public void setOutgoingProperties(Map<String,Object> secProperties) throws SecurityException{
  382.         this.setOutgoingProperties(secProperties, true, false);
  383.     }
  384.     public void setOutgoingProperties(Map<String,Object> secProperties, boolean convertSecProperties) throws SecurityException{
  385.         this.setOutgoingProperties(secProperties, convertSecProperties, false);
  386.     }
  387.     public void setOutgoingProperties(Map<String,Object> secProperties, boolean convertSecProperties, boolean preserveNotStringProperty) throws SecurityException{
  388.         
  389.         if(secProperties!=null && secProperties.size()>0 && convertSecProperties) {
  390.             this.outgoingProperties = convertSecProperties(secProperties, preserveNotStringProperty);
  391.         }
  392.         else {
  393.             this.outgoingProperties = secProperties;
  394.         }
  395.         this.setActor(false);
  396.         this.readMessageSecurityEngine(false);
  397.         this.resolvePWCallback(false);
  398.     }
  399.     public Map<String,Object> getOutgoingProperties() {
  400.         return this.outgoingProperties;
  401.     }
  402.     
  403.     private Map<String,Object> convertSecProperties(Map<String,Object> secProperties, boolean preserveNotStringProperty) throws SecurityException{
  404.         
  405.         try {
  406.         
  407.             Map<String, Object> mapNoStringProperty = new HashMap<>();
  408.             
  409.             Map<String, String> map = new HashMap<>();
  410.             if (secProperties != null && secProperties.size() > 0) {
  411.                 
  412.                 for (String key : secProperties.keySet()) {
  413.                     Object value = secProperties.get(key);
  414.                     String v = null;
  415.                     if(value instanceof String) {
  416.                         v = (String) value;
  417.                     }
  418.                     map.put(key, v);
  419.                     
  420.                     if(preserveNotStringProperty &&
  421.                         value!=null && !(value instanceof String)) {
  422.                         mapNoStringProperty.put(key, value);
  423.                     }
  424.                 }
  425.             }
  426.             
  427.             Map<String, Properties> multiMap = DBPropertiesUtils.toMultiMap(map);
  428.             
  429.             Map<String, Object> table = new HashMap<>();
  430.             
  431.             Properties defaultProperties = MultiPropertiesUtilities.removeDefaultProperties(multiMap);
  432.             if(defaultProperties!=null && defaultProperties.size()>0) {
  433.                 Iterator<?> it = defaultProperties.keySet().iterator();
  434.                 while (it.hasNext()) {
  435.                     Object oKey = it.next();
  436.                     if(oKey instanceof String) {
  437.                         String key = (String) oKey;
  438.                         String value = null;
  439.                         Object oValue = defaultProperties.get(key);
  440.                         if(oValue instanceof String) {
  441.                             value = (String) oValue;
  442.                         }
  443.                         table.put(key, value);
  444.                     }
  445.                 }
  446.             }
  447.             
  448.             if(multiMap.size()>0) { // ho rimosso la mappa di default
  449.                 
  450.                 if(preserveNotStringProperty && mapNoStringProperty.size()>0) {
  451.                     
  452.                     List<String> keysMultiMap = new ArrayList<>();
  453.                     keysMultiMap.addAll(multiMap.keySet());
  454.                     
  455.                     Iterator<String> it = mapNoStringProperty.keySet().iterator();
  456.                     while (it.hasNext()) {
  457.                         String keyWithPrefix = it.next();
  458.                         Object object = mapNoStringProperty.get(keyWithPrefix);
  459.                         
  460.                         String prefix = DBPropertiesUtils.startsWith(keysMultiMap, keyWithPrefix);  
  461.                         if(prefix==null) {
  462.                             table.put(keyWithPrefix, object);
  463.                         }
  464.                         else {
  465.                             String keyWithoutPrefix = DBPropertiesUtils.normalizePropertyName(prefix, keyWithPrefix);
  466.                             multiMap.get(prefix).put(keyWithoutPrefix, object);
  467.                         }
  468.                     }
  469.                     
  470.                 }
  471.                 
  472.                 table.putAll(multiMap);
  473.                 
  474.             }
  475.             else {
  476.                 if(preserveNotStringProperty && mapNoStringProperty.size()>0) {
  477.                     table.putAll(mapNoStringProperty);
  478.                 }
  479.             }
  480.             
  481.             return table;
  482.             
  483.         }catch(Exception e) {
  484.             throw new SecurityException(e.getMessage(),e);
  485.         }
  486.     }
  487.     
  488.     
  489.     
  490.     /** Message Security Engine */   
  491.     public String getSecurityEngine() {
  492.         return this.securityEngine;
  493.     }
  494.     public IMessageSecurityContext getMessageSecurityContext() {
  495.         return this.messageSecurityContext;
  496.     } 
  497.     public IMessageSecuritySender getMessageSecuritySender() {
  498.         return this.messageSecuritySender;
  499.     }
  500.     public IMessageSecurityReceiver getMessageSecurityReceiver() {
  501.         return this.messageSecurityReceiver;
  502.     }
  503.     public IMessageSecurityDigest getMessageSecurityDigest() {
  504.         return this.messageSecurityDigest;
  505.     }
  506.     public IDigestReader getDigestReader(OpenSPCoop2MessageFactory messageFactory) throws SecurityException{
  507.         if(this.messageSecurityDigest!=null){
  508.             return this.getMessageSecurityDigest().getDigestReader(messageFactory, this);
  509.         }
  510.         return null;
  511.     }
  512.     private void readMessageSecurityEngine(boolean incoming) throws SecurityException{
  513.         try{
  514.             
  515.             this.securityEngine = SecurityConstants.SECURITY_ENGINE_WSS4J;
  516.             String engineProperty = null;
  517.             if(incoming){
  518.                 engineProperty = (String) this.incomingProperties.get(SecurityConstants.SECURITY_ENGINE);
  519.             }else{
  520.                 engineProperty = (String) this.outgoingProperties.get(SecurityConstants.SECURITY_ENGINE);
  521.             }
  522.             if(engineProperty!=null){
  523.                 engineProperty = engineProperty.trim();
  524.                 if(SecurityConstants.SECURITY_ENGINE_WSS4J.equals(engineProperty)){
  525.                     // DEFAULT: this.securityEngine = SecurityConstants.SECURITY_ENGINE_WSS4J;
  526.                 }
  527.                 else if(SecurityConstants.SECURITY_ENGINE_SOAPBOX.equals(engineProperty)){
  528.                     this.securityEngine = SecurityConstants.SECURITY_ENGINE_SOAPBOX;
  529.                 }
  530.                 else if(SecurityConstants.SECURITY_ENGINE_JOSE.equals(engineProperty)){
  531.                     this.securityEngine = SecurityConstants.SECURITY_ENGINE_JOSE;
  532.                 }
  533.                 else if(SecurityConstants.SECURITY_ENGINE_XML.equals(engineProperty)){
  534.                     this.securityEngine = SecurityConstants.SECURITY_ENGINE_XML;
  535.                 }
  536.                 else{
  537.                     throw new SecurityException("Security engine impostato ["+engineProperty+"] non supportato");
  538.                 }
  539.             }
  540.             if(SecurityConstants.SECURITY_ENGINE_WSS4J.equals(this.securityEngine)){
  541.                 this.messageSecurityContext = (IMessageSecurityContext) ClassLoaderUtilities.newInstance("org.openspcoop2.security.message.wss4j.MessageSecurityContext_wss4j");
  542.                 this.messageSecuritySender = (IMessageSecuritySender) ClassLoaderUtilities.newInstance("org.openspcoop2.security.message.wss4j.MessageSecuritySender_wss4j");
  543.                 this.messageSecurityReceiver = (IMessageSecurityReceiver) ClassLoaderUtilities.newInstance("org.openspcoop2.security.message.wss4j.MessageSecurityReceiver_wss4j");
  544.                 this.messageSecurityDigest = (IMessageSecurityDigest) ClassLoaderUtilities.newInstance("org.openspcoop2.security.message.wss4j.MessageSecurityDigest_wss4j");
  545.             }else if(SecurityConstants.SECURITY_ENGINE_SOAPBOX.equals(this.securityEngine)){
  546.                 this.messageSecurityContext = (IMessageSecurityContext) ClassLoaderUtilities.newInstance("org.openspcoop2.security.message.soapbox.MessageSecurityContext_soapbox");
  547.                 this.messageSecuritySender = (IMessageSecuritySender) ClassLoaderUtilities.newInstance("org.openspcoop2.security.message.soapbox.MessageSecuritySender_soapbox");
  548.                 this.messageSecurityReceiver = (IMessageSecurityReceiver) ClassLoaderUtilities.newInstance("org.openspcoop2.security.message.soapbox.MessageSecurityReceiver_soapbox");
  549.                 this.messageSecurityDigest = (IMessageSecurityDigest) ClassLoaderUtilities.newInstance("org.openspcoop2.security.message.soapbox.MessageSecurityDigest_soapbox");
  550.             }else if(SecurityConstants.SECURITY_ENGINE_JOSE.equals(this.securityEngine)){
  551.                 this.messageSecurityContext = (IMessageSecurityContext) ClassLoaderUtilities.newInstance("org.openspcoop2.security.message.jose.MessageSecurityContext_jose");
  552.                 this.messageSecuritySender = (IMessageSecuritySender) ClassLoaderUtilities.newInstance("org.openspcoop2.security.message.jose.MessageSecuritySender_jose");
  553.                 this.messageSecurityReceiver = (IMessageSecurityReceiver) ClassLoaderUtilities.newInstance("org.openspcoop2.security.message.jose.MessageSecurityReceiver_jose");
  554.                 this.messageSecurityDigest = (IMessageSecurityDigest) ClassLoaderUtilities.newInstance("org.openspcoop2.security.message.jose.MessageSecurityDigest_jose");
  555.             }else if(SecurityConstants.SECURITY_ENGINE_XML.equals(this.securityEngine)){
  556.                 this.messageSecurityContext = (IMessageSecurityContext) ClassLoaderUtilities.newInstance("org.openspcoop2.security.message.xml.MessageSecurityContext_xml");
  557.                 this.messageSecuritySender = (IMessageSecuritySender) ClassLoaderUtilities.newInstance("org.openspcoop2.security.message.xml.MessageSecuritySender_xml");
  558.                 this.messageSecurityReceiver = (IMessageSecurityReceiver) ClassLoaderUtilities.newInstance("org.openspcoop2.security.message.xml.MessageSecurityReceiver_xml");
  559.                 this.messageSecurityDigest = (IMessageSecurityDigest) ClassLoaderUtilities.newInstance("org.openspcoop2.security.message.xml.MessageSecurityDigest_xml");
  560.             }
  561.             this.messageSecurityContext.init(this);
  562.             
  563.         }catch(Exception e){
  564.             throw new SecurityException(e.getMessage(),e);
  565.         }
  566.     }
  567.     
  568.     
  569.     
  570.     
  571.        
  572.     
  573.     /** resolvePWCallback */
  574.     private void resolvePWCallback(boolean incoming) throws SecurityException{
  575.         try{
  576.             Map<String, Object> props = null;
  577.             if(incoming) {
  578.                 props = this.incomingProperties;
  579.             }else {
  580.                 props = this.outgoingProperties;
  581.             }
  582.             
  583.             boolean pwCallback = props.containsKey(SecurityConstants.PASSWORD_CALLBACK_REF); // non controllo il valore, mi basta la presenza
  584.             props.remove(SecurityConstants.PASSWORD_CALLBACK_REF);
  585.             if(pwCallback) {
  586.                 
  587.                 String aliasGenerico = null;
  588.                 if(props.containsKey(SecurityConstants.USER)) {
  589.                     aliasGenerico = (String) props.get(SecurityConstants.USER);
  590.                 }  
  591.                 
  592.                 HashMap<String, String> mapAliasToPassword = new HashMap<>();
  593.                 
  594.                 if(props.containsKey(SecurityConstants.SIGNATURE_PASSWORD) ||
  595.                         !isPasswordRequired(props, SecurityConstants.SIGNATURE_PROPERTY_REF_ID) ) {
  596.                     String password = (String) props.get(SecurityConstants.SIGNATURE_PASSWORD);
  597.                     String alias = null;
  598.                     if(props.containsKey(SecurityConstants.SIGNATURE_USER)) {
  599.                         alias = (String) props.get(SecurityConstants.SIGNATURE_USER);
  600.                     }
  601.                     else {
  602.                         alias = aliasGenerico;
  603.                     }
  604.                     if(alias!=null){
  605.                         mapAliasToPassword.put(alias, password);
  606.                     }
  607.                 }
  608.                 
  609.                 if(props.containsKey(SecurityConstants.ENCRYPTION_PASSWORD) ||
  610.                         !isPasswordRequired(props, SecurityConstants.ENCRYPTION_PROPERTY_REF_ID) ) {
  611.                     String password = (String) props.get(SecurityConstants.ENCRYPTION_PASSWORD);
  612.                     String alias = null;
  613.                     if(props.containsKey(SecurityConstants.ENCRYPTION_USER)) {
  614.                         alias = (String) props.get(SecurityConstants.ENCRYPTION_USER);
  615.                     }
  616.                     else {
  617.                         alias = aliasGenerico;
  618.                     }
  619.                     if(alias!=null){
  620.                         mapAliasToPassword.put(alias, password);
  621.                     }
  622.                 }

  624.                 if(props.containsKey(SecurityConstants.DECRYPTION_PASSWORD) ||
  625.                         !isPasswordRequired(props, SecurityConstants.DECRYPTION_PROPERTY_REF_ID) ) {
  626.                     String password = (String) props.get(SecurityConstants.DECRYPTION_PASSWORD);
  627.                     String alias = null;
  628.                     if(props.containsKey(SecurityConstants.DECRYPTION_USER)) {
  629.                         alias = (String) props.get(SecurityConstants.DECRYPTION_USER);
  630.                     }
  631.                     else {
  632.                         alias = aliasGenerico;
  633.                     }
  634.                     if(alias!=null){
  635.                         mapAliasToPassword.put(alias, password);
  636.                     }
  637.                 }
  638.                 
  639.                 if(props.containsKey(SecurityConstants.USERNAME_TOKEN_PW)) {
  640.                     String password = (String) props.get(SecurityConstants.USERNAME_TOKEN_PW);
  641.                     String alias = aliasGenerico;
  642.                     if(alias!=null){
  643.                         mapAliasToPassword.put(alias, password);
  644.                     }
  645.                 }
  646.                 
  647.                 if(props.containsKey(SecurityConstants.USERNAME_TOKEN_PW_MAP)) {
  648.                     String mapUserPassword = (String) props.get(SecurityConstants.USERNAME_TOKEN_PW_MAP);
  649.                     if(mapUserPassword!=null && !"".equals(mapUserPassword)) {
  650.                         Properties convertTextToProperties = PropertiesUtilities.convertTextToProperties(mapUserPassword);
  651.                         if(convertTextToProperties!=null && !convertTextToProperties.isEmpty()) {
  652.                             for (Map.Entry<Object,Object> entry : convertTextToProperties.entrySet()) {
  653.                                 if((entry.getKey() instanceof String) && (entry.getValue() instanceof String)) {
  654.                                     String key = (String) entry.getKey();
  655.                                     String value = (String) entry.getValue();
  656.                                     mapAliasToPassword.put(key, value);
  657.                                 }
  658.                             }
  659.                         }
  660.                     }
  661.                 }
  662.                 
  663.                 if(mapAliasToPassword.size()>0) {
  664.                     CallbackHandler pwCallbackHandler = newCallbackHandler(mapAliasToPassword);
  665.                     props.put(SecurityConstants.PASSWORD_CALLBACK_REF, pwCallbackHandler);
  666.                 }
  667.             
  668.             }
  669.         }catch(Exception e){
  670.             throw new SecurityException(e.getMessage(),e);
  671.         }
  672.     }
  673.     
  674.     private static boolean isPasswordRequired(Map<String, Object> props, String refId) {
  675.         Object o = props.get(refId);
  676.         Properties p = null;
  677.         if(o instanceof Properties) {
  678.             p = (Properties) o;
  679.         }
  680.         return isPasswordRequired(p, true);
  681.     }
  682.     public static boolean isPasswordRequired(Properties pr, boolean key) {
  683.         String keystoreType = null;
  684.         keystoreType = pr!=null ? pr.getProperty(KeystoreConstants.PROPERTY_KEYSTORE_TYPE) : null;
  685.         if(keystoreType!=null){
  686.             keystoreType = keystoreType.trim();
  687.         }else{
  688.             keystoreType = KeyStore.getDefaultType();
  689.         }
  690.         boolean required = true;
  691.         if(KeystoreType.JKS.isType(keystoreType)) {
  692.             required = key ? DBUtils.isKeystoreJksKeyPasswordRequired() : DBUtils.isKeystoreJksPasswordRequired();
  693.         }
  694.         else if(KeystoreType.PKCS12.isType(keystoreType)) {
  695.             required = key ? DBUtils.isKeystorePkcs12KeyPasswordRequired() : DBUtils.isKeystorePkcs12PasswordRequired();
  696.         }
  697.         return required;
  698.     }
  699.     
  700.     public static CallbackHandler newCallbackHandler(Map<String, String> mapAliasToPassword) {
  701.         return new CallbackHandler() {
  702.             
  703.             private Map<String, String> mapAliasToPasswordParam = mapAliasToPassword;
  704.             
  705.             @Override
  706.             public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException {
  707.                  for (int i = 0; i < callbacks.length; i++) {
  708.                      if (callbacks[i] instanceof WSPasswordCallback) {
  709.                             WSPasswordCallback pc = (WSPasswordCallback) callbacks[i];
  710.                             if(this.mapAliasToPasswordParam.containsKey(pc.getIdentifier())) {
  711.                                 pc.setPassword(this.mapAliasToPasswordParam.get(pc.getIdentifier()));
  712.                             }
  713.                         } else {
  714.                             throw new UnsupportedCallbackException(callbacks[i],
  715.                                     "Unrecognized Callback");
  716.                         }
  717.                     }
  718.             }
  719.             
  720.         };
  721.     }
  722.     
  723.     /** Utility per verificare l'esistenza di un header di sicurezza */
  724.     public boolean existsSecurityHeader(OpenSPCoop2Message msg,String actor){
  725.         SOAPHeader header = null;
  726.         try{
  727.             if(msg==null){
  728.                 return false;
  729.             }
  730.             if(ServiceBinding.SOAP.equals(msg.getServiceBinding())){
  731.                 OpenSPCoop2SoapMessage soapMsg = msg.castAsSoap();
  732.                 header = soapMsg.getSOAPHeader();
  733.             }
  734.             else{
  735.                 return true;
  736.             }
  737.         }catch(Exception e){
  738.             if(this.log!=null)
  739.                 this.log.error("existsHeaderMessageSecurity error con actor["+actor+"]",e);
  740.             return false;
  741.         }
  742.         return existsSecurityHeader(msg.getFactory(), msg.getMessageType(), 
  743.                 header, actor);
  744.     }
  745.     public boolean existsSecurityHeader(OpenSPCoop2Message msg,String actor, 
  746.             boolean bufferMessage_readOnly, String idTransazione){
  747.         SOAPEnvelope soapEnvelope = null;
  748.         try{
  749.             if(msg==null){
  750.                 return false;
  751.             }
  752.             if(ServiceBinding.SOAP.equals(msg.getServiceBinding())){
  753.                 OpenSPCoop2SoapMessage soapMsg = msg.castAsSoap();
  754.                 SOAPPart soapPart = MessageUtils.getSOAPPart(soapMsg, bufferMessage_readOnly, idTransazione);
  755.                 if(soapPart!=null) {
  756.                     soapEnvelope = soapPart.getEnvelope();
  757.                 }
  758.             }
  759.             else{
  760.                 return true;
  761.             }
  762.         }catch(Exception e){
  763.             if(this.log!=null)
  764.                 this.log.error("existsHeaderMessageSecurity error con actor["+actor+"]",e);
  765.             return false;
  766.         }
  767.         return existsSecurityHeader(msg.getFactory(), msg.getMessageType(), 
  768.                 soapEnvelope, actor);
  769.     }
  770.     public boolean existsSecurityHeader(OpenSPCoop2MessageFactory messageFactory, MessageType messageType, 
  771.             SOAPEnvelope soapEnvelope,String actor){
  772.         SOAPHeader header = null;
  773.         try{
  774.             header = soapEnvelope.getHeader();
  775.         }catch(Exception e){
  776.             if(this.log!=null)
  777.                 this.log.error("existsHeaderMessageSecurity error con actor["+actor+"]",e);
  778.             return false;
  779.         }
  780.         return existsSecurityHeader(messageFactory, messageType, 
  781.                 header, actor);
  782.     }
  783.     public boolean existsSecurityHeader(OpenSPCoop2MessageFactory messageFactory, MessageType messageType, 
  784.             SOAPHeader header,String actor){
  785.         try{
  786.             if(header==null || (SoapUtils.getNotEmptyChildNodes(messageFactory, header).isEmpty()) ){
  787.                 return false;
  788.             }
  789.             java.util.Iterator<?> it = header.examineAllHeaderElements();
  790.             while( it.hasNext()  ){
  791.                 
  792.                 // Test Header Element
  793.                 SOAPHeaderElement headerElement = (SOAPHeaderElement) it.next();
  794.                 if(   SecurityConstants.WSS_HEADER_ELEMENT.equals(headerElement.getLocalName()) &&
  795.                         SecurityConstants.WSS_HEADER_ELEMENT_NAMESPACE.equals(headerElement.getNamespaceURI()) ){
  796.                         // potenziale header, verifico l'actor
  797.                     String actorCheck = SoapUtils.getSoapActor(headerElement, messageType);
  798.                     if(actor==null){
  799.                         if(actorCheck==null) {
  800.                             return true;
  801.                         }
  802.                     }else{
  803.                         if(actor.equals(actorCheck)) {
  804.                             return true;
  805.                         }
  806.                     }
  807.                 }
  808.                 
  809.             }
  810.             return false;
  811.         }catch(Exception e){
  812.             if(this.log!=null)
  813.                 this.log.error("existsHeaderMessageSecurity error con actor["+actor+"]",e);
  814.             return false;
  815.         }
  816.     }
  817.     
  818.     

  820.     public SOAPHeaderElement getSecurityHeader(OpenSPCoop2Message msg,String actor){
  821.         SOAPHeader header = null;
  822.         try{
  823.             if(msg==null){
  824.                 return null;
  825.             }
  826.             if(ServiceBinding.SOAP.equals(msg.getServiceBinding())){
  827.                 OpenSPCoop2SoapMessage soapMsg = msg.castAsSoap();
  828.                 header = soapMsg.getSOAPHeader();
  829.             }
  830.             else{
  831.                 return null;
  832.             }
  833.         }catch(Exception e){
  834.             if(this.log!=null)
  835.                 this.log.error("getHeaderMessageSecurity error con actor["+actor+"]",e);
  836.             return null;
  837.         }
  838.         return getSecurityHeader(msg.getFactory(), msg.getMessageType(), 
  839.                 header, actor);
  840.     }
  841.     public SOAPHeaderElement getSecurityHeader(OpenSPCoop2Message msg,String actor, 
  842.             boolean bufferMessageReadOnly, String idTransazione){
  843.         SOAPEnvelope soapEnvelope = null;
  844.         try{
  845.             if(msg==null){
  846.                 return null;
  847.             }
  848.             if(ServiceBinding.SOAP.equals(msg.getServiceBinding())){
  849.                 OpenSPCoop2SoapMessage soapMsg = msg.castAsSoap();
  850.                 SOAPPart soapPart = MessageUtils.getSOAPPart(soapMsg, bufferMessageReadOnly, idTransazione);
  851.                 if(soapPart!=null) {
  852.                     soapEnvelope = soapPart.getEnvelope();
  853.                 }
  854.             }
  855.             else{
  856.                 return null;
  857.             }
  858.         }catch(Exception e){
  859.             if(this.log!=null)
  860.                 this.log.error("getHeaderMessageSecurity error con actor["+actor+"]",e);
  861.             return null;
  862.         }
  863.         return getSecurityHeader(msg.getFactory(), msg.getMessageType(), 
  864.                 soapEnvelope, actor);
  865.     }
  866.     public SOAPHeaderElement getSecurityHeader(OpenSPCoop2MessageFactory messageFactory, MessageType messageType, 
  867.             SOAPEnvelope soapEnvelope,String actor){
  868.         SOAPHeader header = null;
  869.         try{
  870.             header = soapEnvelope.getHeader();
  871.         }catch(Exception e){
  872.             if(this.log!=null)
  873.                 this.log.error("getHeaderMessageSecurity error con actor["+actor+"]",e);
  874.             return null;
  875.         }
  876.         return getSecurityHeader(messageFactory, messageType, 
  877.                 header, actor);
  878.     }
  879.     public SOAPHeaderElement getSecurityHeader(OpenSPCoop2MessageFactory messageFactory, MessageType messageType, 
  880.             SOAPHeader header,String actor){
  881.         try{
  882.             if(header==null || (SoapUtils.getNotEmptyChildNodes(messageFactory, header).isEmpty()) ){
  883.                 return null;
  884.             }
  885.             java.util.Iterator<?> it = header.examineAllHeaderElements();
  886.             while( it.hasNext()  ){
  887.                 
  888.                 // Test Header Element
  889.                 SOAPHeaderElement headerElement = (SOAPHeaderElement) it.next();
  890.                 if(   SecurityConstants.WSS_HEADER_ELEMENT.equals(headerElement.getLocalName()) &&
  891.                         SecurityConstants.WSS_HEADER_ELEMENT_NAMESPACE.equals(headerElement.getNamespaceURI()) ){
  892.                         // potenziale header, verifico l'actor
  893.                     String actorCheck = SoapUtils.getSoapActor(headerElement, messageType);
  894.                     if(actor==null){
  895.                         if(actorCheck==null) {
  896.                             return headerElement;
  897.                         }
  898.                     }else{
  899.                         if(actor.equals(actorCheck)) {
  900.                             return headerElement;
  901.                         }
  902.                     }
  903.                 }
  904.                 
  905.             }
  906.             return null;
  907.         }catch(Exception e){
  908.             if(this.log!=null)
  909.                 this.log.error("getHeaderMessageSecurity error con actor["+actor+"]",e);
  910.             return null;
  911.         }
  912.     }

  914.     
  915.     /** Utility per verificare l'esistenza di un header di sicurezza */
  916.     public SOAPElement getSAMLTokenInSecurityHeader(OpenSPCoop2MessageFactory messageFactory, SOAPHeaderElement securityHeader,String samlVersion){
  917.         try{
  918.             SOAPElement samlElement = null;
  919.                         
  920.             DynamicNamespaceContext dnc = new DynamicNamespaceContext();
  921.             dnc.findPrefixNamespace(securityHeader);
  922.                         
  923.             AbstractXPathExpressionEngine xpathExpressionEngine = new XPathExpressionEngine(messageFactory);
  924.             String xpath =null;
  925.             if(SecurityConstants.SAML_VERSION_XMLCONFIG_ID_VALUE_20.equals(samlVersion)) {
  926.                 xpath = SAMLConstants.XPATH_SAML_20_ASSERTION;
  927.             }
  928.             else {
  929.                 xpath = SAMLConstants.XPATH_SAML_11_ASSERTION;
  930.             }
  931.             try {
  932.                 Object o = xpathExpressionEngine.getMatchPattern(securityHeader, dnc, xpath, XPathReturnType.NODE);
  933.                 samlElement = (SOAPElement) o;
  934.             } catch(XPathNotFoundException e) {
  935.                 // ignore
  936.             }
  937.             
  938.             return samlElement;

  940.         }catch(Exception e){
  941.             if(this.log!=null)
  942.                 this.log.error("getSAMLTokenInSecurityHeader error, saml version: ["+samlVersion+"]",e);
  943.             return null;
  944.         }
  945.     }

  947.     public String getSAMLTokenSubjectConfirmationMethodInSecurityHeader(OpenSPCoop2MessageFactory messageFactory, SOAPElement samlToken,String samlVersion){
  948.         try{
  949.                 
  950.             DynamicNamespaceContext dnc = new DynamicNamespaceContext();
  951.             dnc.findPrefixNamespace(samlToken);
  952.                     
  953.             AbstractXPathExpressionEngine xpathExpressionEngine = new XPathExpressionEngine(messageFactory);
  954.             String xpath =null;
  955.             if(SecurityConstants.SAML_VERSION_XMLCONFIG_ID_VALUE_20.equals(samlVersion)) {
  956.                 xpath = SAMLConstants.XPATH_SAML_20_ASSERTION_SUBJECT_CONFIRMATION_METHOD;
  957.             }
  958.             else {
  959.                 xpath = SAMLConstants.XPATH_SAML_11_ASSERTION_SUBJECT_CONFIRMATION_METHOD;
  960.             }
  961.             String method = null;
  962.             try {
  963.                 Object o = xpathExpressionEngine.getMatchPattern(samlToken, dnc, xpath, XPathReturnType.STRING);
  964.                 method = (String) o;
  965.             } catch(XPathNotFoundException e) {
  966.                 // ignore
  967.             }
  968.             
  969.             return method;

  971.         }catch(Exception e){
  972.             if(this.log!=null)
  973.                 this.log.error("getSAMLTokenSubjectConfirmationMethodInSecurityHeader error, saml version: ["+samlVersion+"]",e);
  974.             return null;
  975.         }   
  976. }
  977.     
  978. }
Created with JaCoCo 0.8.8.202204050719