MessageSecurityReceiver_wss4j.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.wss4j;

  24. import java.io.ByteArrayOutputStream;
  25. import java.io.FileNotFoundException;
  26. import java.io.PrintStream;
  27. import java.net.URISyntaxException;
  28. import java.security.KeyStore;
  29. import java.security.Principal;
  30. import java.security.PublicKey;
  31. import java.security.cert.Certificate;
  32. import java.security.cert.X509Certificate;
  33. import java.util.ArrayList;
  34. import java.util.HashMap;
  35. import java.util.List;
  36. import java.util.Map;
  37. import java.util.Properties;

  39. import javax.security.auth.callback.CallbackHandler;
  40. import javax.xml.namespace.QName;
  41. import javax.xml.soap.SOAPMessage;

  43. import org.apache.cxf.binding.soap.SoapMessage;
  44. import org.apache.cxf.message.Attachment;
  45. import org.apache.cxf.message.Exchange;
  46. import org.apache.cxf.message.ExchangeImpl;
  47. import org.apache.cxf.message.MessageImpl;
  48. import org.apache.cxf.ws.security.wss4j.WSS4JInInterceptor;
  49. import org.apache.wss4j.common.crypto.Merlin;
  50. import org.apache.wss4j.common.ext.WSSecurityException;
  51. import org.apache.wss4j.dom.WSConstants;
  52. import org.apache.wss4j.dom.WSDataRef;
  53. import org.apache.wss4j.dom.engine.WSSecurityEngineResult;
  54. import org.apache.wss4j.dom.handler.WSHandlerConstants;
  55. import org.apache.wss4j.dom.handler.WSHandlerResult;
  56. import org.apache.wss4j.dom.message.token.Timestamp;
  57. import org.apache.wss4j.dom.str.STRParser;
  58. import org.openspcoop2.core.constants.Costanti;
  59. import org.openspcoop2.message.MessageUtils;
  60. import org.openspcoop2.message.OpenSPCoop2Message;
  61. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  62. import org.openspcoop2.message.constants.MessageType;
  63. import org.openspcoop2.message.constants.ServiceBinding;
  64. import org.openspcoop2.message.soap.reference.Reference;
  65. import org.openspcoop2.protocol.sdk.Busta;
  66. import org.openspcoop2.protocol.sdk.constants.CodiceErroreCooperazione;
  67. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  68. import org.openspcoop2.security.SecurityException;
  69. import org.openspcoop2.security.keystore.CRLCertstore;
  70. import org.openspcoop2.security.keystore.KeystoreConstants;
  71. import org.openspcoop2.security.keystore.MerlinTruststore;
  72. import org.openspcoop2.security.keystore.cache.GestoreKeystoreCache;
  73. import org.openspcoop2.security.keystore.cache.GestoreOCSPResource;
  74. import org.openspcoop2.security.keystore.cache.GestoreOCSPValidator;
  75. import org.openspcoop2.security.message.AbstractSOAPMessageSecurityReceiver;
  76. import org.openspcoop2.security.message.MessageSecurityContext;
  77. import org.openspcoop2.security.message.SubErrorCodeSecurity;
  78. import org.openspcoop2.security.message.constants.SecurityConstants;
  79. import org.openspcoop2.security.message.engine.MessageUtilities;
  80. import org.openspcoop2.security.message.engine.WSSUtilities;
  81. import org.openspcoop2.security.message.utils.AttachmentProcessingPart;
  82. import org.openspcoop2.security.message.utils.AttachmentsConfigReaderUtils;
  83. import org.openspcoop2.security.message.utils.EncryptionBean;
  84. import org.openspcoop2.security.message.utils.KeystoreUtils;
  85. import org.openspcoop2.utils.LoggerBuffer;
  86. import org.openspcoop2.utils.Utilities;
  87. import org.openspcoop2.utils.UtilsException;
  88. import org.openspcoop2.utils.certificate.CertificateInfo;
  89. import org.openspcoop2.utils.id.IDUtilities;
  90. import org.openspcoop2.utils.transport.http.IOCSPValidator;



  94. /**
  95.  * Classe per la gestione della WS-Security (WSDoAllReceiver).
  96.  *
  97.  * @author Lorenzo Nardi (nardi@link.it)
  98.  * @author Tommaso Burlon (tommaso.burlon@link.it)
  99.  * @author $Author$
  100.  * @version $Rev$, $Date$
  101.  * 
  102.  */
  103. public class MessageSecurityReceiver_wss4j extends AbstractSOAPMessageSecurityReceiver{


  106.     @Override
  107.     public void process(MessageSecurityContext wssContext,OpenSPCoop2Message messageParam,Busta busta, org.openspcoop2.utils.Map<Object> ctx) throws SecurityException{
  108.         process(wssContext, messageParam, busta,
  109.                 false, null, ctx);
  110.     }
  111.     public void process(MessageSecurityContext wssContext,OpenSPCoop2Message messageParam,Busta busta,
  112.             boolean bufferMessage_readOnly, String idTransazione, org.openspcoop2.utils.Map<Object> ctx) throws SecurityException{
  113.         boolean certError = false;
  114.         boolean ocspError = false;
  115.         try{
  116.             
  117.             if(ServiceBinding.SOAP.equals(messageParam.getServiceBinding())==false){
  118.                 throw new SecurityException("WSS4J Engine usable only with SOAP Binding");
  119.             }
  120.             OpenSPCoop2SoapMessage message = messageParam.castAsSoap();
  121.             SOAPMessage soapMessage = MessageUtils.getSOAPMessage(message, bufferMessage_readOnly, idTransazione);
  122.             
  123.             RequestInfo requestInfo = null;
  124.             if(ctx!=null && ctx.containsKey(Costanti.REQUEST_INFO)) {
  125.                 requestInfo = (RequestInfo) ctx.get(Costanti.REQUEST_INFO);
  126.             }
  127.             
  128.             
  129.             // ** Inizializzo handler CXF **/
  130.             
  131.             WSS4JInInterceptor inHandler = new WSS4JInInterceptor();
  132.             SoapMessage msgCtx = new SoapMessage(new MessageImpl());
  133.             msgCtx.setVersion(MessageType.SOAP_12.equals(message.getMessageType()) ? org.apache.cxf.binding.soap.Soap12.getInstance() : org.apache.cxf.binding.soap.Soap11.getInstance());
  134.             Exchange ex = new ExchangeImpl();
  135.             ex.setInMessage(msgCtx);
  136.             msgCtx.setContent(SOAPMessage.class, soapMessage);
  137.             setIncomingProperties(wssContext,inHandler,msgCtx,requestInfo,ctx);
  138.             
  139.             
  140.             // ** Registro attachments da trattare **/
  141.             
  142.             AttachmentProcessingPart app = AttachmentsConfigReaderUtils.getSecurityOnAttachments(wssContext);
  143.             List<Attachment> listAttachments = null;
  144.             if(app!=null){
  145.                 // Non è possibile effettuare il controllo della posizione puntuale sulla ricezione. 
  146.                 // Può essere usato solo per specificare quale attach firmare/cifrare in spedizione
  147.                 // Alcune implementazioni modificano l'ordine degli attachments una volta applicata la sicurezza
  148.                 if(app.isAllAttachments()==false){
  149.                     List<String> cidAttachmentsForSecurity = AttachmentsConfigReaderUtils.getListCIDAttachmentsForSecurity(wssContext);
  150.                     listAttachments = org.openspcoop2.security.message.wss4j.WSSUtilities.readAttachments(cidAttachmentsForSecurity, message, msgCtx);
  151.                 }
  152.                 else{
  153.                     listAttachments = org.openspcoop2.security.message.wss4j.WSSUtilities.readAttachments(app, message, msgCtx);
  154.                 }
  155.                 if(listAttachments!=null && listAttachments.size()>0){
  156.                     msgCtx.setAttachments(listAttachments);
  157.                 }
  158.             }
  159.             
  160.             
  161.             // ** Applico sicurezza tramite CXF **/
  162.             
  163.             inHandler.handleMessage(msgCtx);
  164.             List<?> results = (List<?>) msgCtx.getContextualProperty(WSHandlerConstants.RECV_RESULTS);
  165.             wssContext.getLog().debug("Print wssRecever results...");
  166.             org.openspcoop2.security.message.wss4j.WSSUtilities.printWSResult(wssContext.getLog(), results);
  167.             
  168.             
  169.             // ** Riporto modifica degli attachments **/
  170.             
  171.             org.openspcoop2.security.message.wss4j.WSSUtilities.updateAttachments(listAttachments, message, msgCtx);
  172.             
  173.             
  174.             // ** Lettura Subject Certificato e informazioni relative al processamento effettuato **/
  175.             
  176.             boolean validateX509 = this.examineResults(msgCtx, wssContext.getActor());
  177.             
  178.             
  179.             // ** Validazione CRL se non effettuata dall'handler (indicazione arriva dal metodo examineResults) **
  180.             
  181.             if(validateX509) {
  182.                 if(this.x509Certificate!=null && this.crlX509!=null) {
  183.                     try {
  184.                         CertificateInfo certificatoInfo = new CertificateInfo(this.x509Certificate, "x509");
  185.                         certificatoInfo.checkValid(this.crlX509.getCertStore(), this.trustStore);
  186.                     }catch(Throwable e) {
  187.                         certError = true;
  188.                         throw new Exception(e.getMessage(),e);
  189.                     }
  190.                 }   
  191.             }
  192.             
  193.             // ** Lettura Subject Certificato e informazioni relative al processamento effettuato **/
  194.             
  195.             if(this.ocspValidator!=null) {
  196.                 X509Certificate cert = this.x509Certificate;
  197.                 if(cert==null && this.x509Certificates!=null && this.x509Certificates.length>0) {
  198.                     cert = this.x509Certificates[0];
  199.                 }
  200.                 if(cert!=null) {
  201.                     try {
  202.                         this.ocspValidator.valid(cert);
  203.                     }catch(Throwable e) {
  204.                         ocspError = true;
  205.                         throw e;
  206.                     }
  207.                 }
  208.             }           
  209.             
  210.         } catch (Throwable e) {
  211.             
  212.             SecurityException wssException = null;
  213.             
  214.             
  215.             /* **** MESSAGGIO ***** */
  216.             String msg = Utilities.getInnerNotEmptyMessageException(e).getMessage();
  217.             
  218.             Throwable innerExc = Utilities.getLastInnerException(e);
  219.             String innerMsg = null;
  220.             if(innerExc!=null){
  221.                 innerMsg = innerExc.getMessage();
  222.             }
  223.             
  224.             String messaggio = null;
  225.             if(msg!=null){
  226.                 messaggio = new String(msg);
  227.                 if(innerMsg!=null && !innerMsg.equals(msg)){
  228.                     messaggio = messaggio + " ; " + innerMsg;
  229.                 }
  230.             }
  231.             else{
  232.                 if(innerMsg!=null){
  233.                     messaggio = innerMsg;
  234.                 }
  235.             }
  236.             
  237.             // L'if scopre l'eventuale motivo preciso riguardo al fallimento della cifratura/firma.
  238.             if(Utilities.existsInnerException(e, WSSecurityException.class)){
  239.                 Throwable t = Utilities.getLastInnerException(e);
  240.                 if(t instanceof WSSecurityException){
  241.                     if(messaggio!=null){
  242.                         messaggio = messaggio + " ; " + t.getMessage();
  243.                     }
  244.                     else{
  245.                         messaggio = t.getMessage();
  246.                     }
  247.                 }
  248.             }
  249.             
  250.             wssException = new SecurityException(messaggio, e);
  251.             wssException.setMsgErrore(messaggio);
  252.             
  253.             
  254.             /* ***** CODICE **** */
  255.             
  256.             boolean signature = false;
  257.             boolean encrypt = false;
  258.             try{
  259.                 ByteArrayOutputStream bout = new ByteArrayOutputStream();
  260.                 PrintStream printStream = new PrintStream(bout);
  261.                 e.printStackTrace(printStream);
  262.                 bout.flush();
  263.                 printStream.flush();
  264.                 bout.close();
  265.                 printStream.close();
  266.                 
  267.                 if(certError) {
  268.                     signature = true; // per adesso avviene solo con SAML
  269.                 }
  270.                 else if(ocspError) {
  271.                     signature = true;
  272.                 }
  273.                 else if(bout.toString().contains(".processor.SignatureProcessor")){
  274.                     signature = true;
  275.                 }
  276.                 else if(bout.toString().contains(".processor.SignatureConfirmationProcessor")){
  277.                     signature = true;
  278.                 }
  279.                 else if(bout.toString().contains(".processor.EncryptedKeyProcessor")){
  280.                     encrypt = true;
  281.                 }
  282.                 else if(bout.toString().contains(".processor.EncryptedDataProcessor")){
  283.                     encrypt = true;
  284.                 }
  285.                 
  286.             }catch(Exception eClose){}
  287.             
  288.             if(signature){
  289.                 wssException.setCodiceErrore(CodiceErroreCooperazione.SICUREZZA_FIRMA_NON_VALIDA);
  290.             }
  291.             else if(encrypt){
  292.                 wssException.setCodiceErrore(CodiceErroreCooperazione.SICUREZZA_CIFRATURA_NON_VALIDA);
  293.             }
  294.             else if(Utilities.existsInnerMessageException(e, "The signature or decryption was invalid", true)){
  295.                 wssException.setCodiceErrore(CodiceErroreCooperazione.SICUREZZA_FIRMA_NON_VALIDA);
  296.             } else {
  297.                 wssException.setCodiceErrore(CodiceErroreCooperazione.SICUREZZA);
  298.             }
  299.             
  300.             
  301.             throw wssException;
  302.         }

  304.     }

  306.     private Timestamp timestamp;
  307.     public Timestamp getTimestamp() {
  308.         return this.timestamp;
  309.     }
  310.     
  311.     private List<WSDataRef> signatureRefs;
  312.     public List<WSDataRef> getSignatureRefs() {
  313.         return this.signatureRefs;
  314.     }

  316.     private List<WSDataRef> encryptionRefs;
  317.     public List<WSDataRef> getEncryptionRefs() {
  318.         return this.encryptionRefs;
  319.     }
  320.     
  321.     private String certificate;
  322.     private STRParser.REFERENCE_TYPE x509ReferenceType;
  323.     private X509Certificate x509Certificate;
  324.     private X509Certificate [] x509Certificates;
  325.     private PublicKey publicKey;
  326.     @Override
  327.     public String getCertificate() throws SecurityException{
  328.         return this.certificate;
  329.     }
  330.     public STRParser.REFERENCE_TYPE getX509ReferenceType() {
  331.         return this.x509ReferenceType;
  332.     }
  333.     @Override
  334.     public X509Certificate getX509Certificate() throws SecurityException {
  335.         return this.x509Certificate;
  336.     }
  337.     public X509Certificate[] getX509Certificates() {
  338.         return this.x509Certificates;
  339.     }
  340.     @Override
  341.     public PublicKey getPublicKey() {
  342.         return this.publicKey;
  343.     }
  344.     @Override
  345.     public String getCertificateId() throws SecurityException{
  346.         return null;
  347.     }

  349.     private IOCSPValidator ocspValidator;
  350.     private org.openspcoop2.utils.certificate.KeyStore trustStore = null;
  351.     private CRLCertstore crlX509 = null;
  352.     private void setIncomingProperties(MessageSecurityContext wssContext,WSS4JInInterceptor interceptor, SoapMessage msgCtx, RequestInfo requestInfo,
  353.             org.openspcoop2.utils.Map<Object> ctx) throws SecurityException {
  354.         Map<String,Object> wssIncomingProperties =  wssContext.getIncomingProperties();
  355.         String ocspPolicy = null;
  356.         String crls = null;
  357.         Properties pTrustStore = null;
  358.         boolean samlSigned = false;
  359.         if (wssIncomingProperties != null && wssIncomingProperties.size() > 0) {
  360.             
  361.             // preprocess per multipropfile
  362.             try {
  363.                 preprocessMultipropFile(wssContext, msgCtx, wssIncomingProperties, requestInfo, ctx);
  364.             }catch(Exception e) {
  365.                 throw new SecurityException(e.getMessage(),e);
  366.             }
  367.             
  368.             for (String key : wssIncomingProperties.keySet()) {
  369.                 Object oValue = wssIncomingProperties.get(key);
  370.                 String value = null;
  371.                 if(oValue!=null && oValue instanceof String) {
  372.                     value = (String) oValue;
  373.                 }
  374.                 if(SecurityConstants.ACTION.equals(key)) {
  375.                     msgCtx.put(key, value);
  376.                     interceptor.setProperty(key, value);
  377.                     if(value!=null && value.contains(SecurityConstants.ACTION_SAML_TOKEN_SIGNED)) {
  378.                         samlSigned = true;
  379.                     }
  380.                 }
  381.                 else if(SecurityConstants.PASSWORD_CALLBACK_REF.equals(key)) {
  382.                     msgCtx.put(key, oValue);
  383.                 }
  384.                 else if(SecurityConstants.SIGNATURE_PROPERTY_REF_ID.equals(key) || 
  385.                         SecurityConstants.SIGNATURE_VERIFICATION_PROPERTY_REF_ID.equals(key) || 
  386.                         SecurityConstants.SIGNATURE_TRUSTSTORE_PROPERTY_REF_ID.equals(key) || 
  387.                         SecurityConstants.ENCRYPTION_PROPERTY_REF_ID.equals(key) || 
  388.                         SecurityConstants.DECRYPTION_PROPERTY_REF_ID.equals(key) ) {
  389.                     if(value!=null) {
  390.                         msgCtx.put(key, value);
  391.                     }
  392.                     else { 
  393.                         String id = key+"_"+IDUtilities.getUniqueSerialNumber("wssSecurity.setIncomingProperties");
  394.                         msgCtx.put(key, id);
  395.                         msgCtx.put(id, oValue);
  396.                         if(oValue!=null && oValue instanceof Properties) {
  397.                             Properties p = (Properties) oValue;
  398.                             p.put(KeystoreConstants.PROPERTY_REQUEST_INFO, requestInfo);
  399.                             if(SecurityConstants.SIGNATURE_PROPERTY_REF_ID.equals(key) || 
  400.                                     SecurityConstants.SIGNATURE_VERIFICATION_PROPERTY_REF_ID.equals(key) || 
  401.                                     SecurityConstants.SIGNATURE_TRUSTSTORE_PROPERTY_REF_ID.equals(key) ) {
  402.                                 pTrustStore = p;
  403.                             }
  404.                         }
  405.                     }
  406.                 }
  407.                 else if(SecurityConstants.ENCRYPT_ACTION_OLD.equals(key)) {
  408.                     // backward compatibility per adeguamento costante rispetto a wss4j 2.3.x
  409.                     msgCtx.put(SecurityConstants.ENCRYPTION_ACTION, value);
  410.                     interceptor.setProperty(SecurityConstants.ENCRYPTION_ACTION, value);
  411.                 }
  412.                 else if(SecurityConstants.SIGNATURE_OCSP.equals(key)) {
  413.                     ocspPolicy = value;
  414.                 }
  415.                 else if(SecurityConstants.SIGNATURE_CRL.equals(key)) {
  416.                     crls = value;
  417.                 }
  418.                 else{
  419.                     msgCtx.put(key, value);
  420.                     interceptor.setProperty(key, value);
  421.                 }
  422.             }
  423.         }
  424.         if(wssContext.getActor()!=null){
  425.             interceptor.setProperty(SecurityConstants.ACTOR, wssContext.getActor());
  426.             msgCtx.put(SecurityConstants.ACTOR, wssContext.getActor());
  427.         }
  428.         
  429.         String prefixTrustStore = null;
  430.         if(pTrustStore!=null && !pTrustStore.isEmpty()) {
  431.             String trustStoreLocation = null;
  432.             try {
  433.                 //
  434.                 // Load the TrustStore (serve ad avere x509 in alcuni casi durante l'esamina della risposta)
  435.                 //
  436.                 prefixTrustStore = org.openspcoop2.security.keystore.MerlinProvider.readPrefix(pTrustStore);
  437.                 
  438.                 trustStoreLocation = pTrustStore.getProperty(prefixTrustStore + Merlin.TRUSTSTORE_FILE);
  439.                 String trustStorePassword = null;
  440.                 String trustStoreType = null;
  441.                 if (trustStoreLocation == null) {
  442.                     trustStoreLocation = pTrustStore.getProperty(prefixTrustStore + Merlin.KEYSTORE_FILE);
  443.                     if (trustStoreLocation == null) {
  444.                         trustStoreLocation = pTrustStore.getProperty(prefixTrustStore + Merlin.OLD_KEYSTORE_FILE);
  445.                     }
  446.                     if (trustStoreLocation != null) {
  447.                         trustStorePassword = pTrustStore.getProperty(prefixTrustStore + Merlin.KEYSTORE_PASSWORD);
  448.                         if (trustStorePassword != null) {
  449.                             trustStorePassword = trustStorePassword.trim();
  450.                         }
  451.                         trustStoreType = pTrustStore.getProperty(prefixTrustStore + Merlin.KEYSTORE_TYPE, KeyStore.getDefaultType());
  452.                         if (trustStoreType != null) {
  453.                             trustStoreType = trustStoreType.trim();
  454.                         }
  455.                     }
  456.                 }
  457.                 else {
  458.                     trustStorePassword = pTrustStore.getProperty(prefixTrustStore + Merlin.TRUSTSTORE_PASSWORD);
  459.                     if (trustStorePassword != null) {
  460.                         trustStorePassword = trustStorePassword.trim();
  461.                     }
  462.                     trustStoreType = pTrustStore.getProperty(prefixTrustStore + Merlin.TRUSTSTORE_TYPE, KeyStore.getDefaultType());
  463.                     if (trustStoreType != null) {
  464.                         trustStoreType = trustStoreType.trim();
  465.                     }
  466.                 }
  467.                 if (trustStoreLocation != null) {
  468.                     trustStoreLocation = trustStoreLocation.trim();
  469.                     MerlinTruststore merlinTs = GestoreKeystoreCache.getMerlinTruststore(requestInfo, trustStoreLocation, trustStoreType, 
  470.                             trustStorePassword);
  471.                     if(merlinTs==null) {
  472.                         throw new Exception("Accesso al truststore '"+trustStoreLocation+"' non riuscito");
  473.                     }
  474.                     if(merlinTs.getTrustStore()==null) {
  475.                         throw new Exception("Accesso al truststore '"+trustStoreLocation+"' non riuscito");
  476.                     }
  477.                     this.trustStore = merlinTs.getTrustStore();
  478.                 }
  479.             }catch(Exception e) {
  480.                 throw new SecurityException("[Truststore-File] '"+trustStoreLocation+"': "+e.getMessage(),e);
  481.             }
  482.         }
  483.         
  484.         boolean crlByOcsp = false;
  485.         if(ocspPolicy!=null&& !"".equals(ocspPolicy)) {
  486.             
  487.             if(this.trustStore!=null) {
  488.                 LoggerBuffer lb = new LoggerBuffer();
  489.                 lb.setLogDebug(wssContext.getLog());
  490.                 lb.setLogError(wssContext.getLog());
  491.                 GestoreOCSPResource ocspResourceReader = new GestoreOCSPResource(requestInfo);
  492.                 IOCSPValidator ocspValidator = null;
  493.                 try {
  494.                     ocspValidator = new GestoreOCSPValidator(requestInfo, lb, 
  495.                             this.trustStore,
  496.                             crls, 
  497.                             ocspPolicy, 
  498.                             ocspResourceReader);
  499.                 }catch(Exception e){
  500.                     throw new SecurityException("SignatureVerifier; ocsp initialization (policy:'"+ocspPolicy+"') failed: "+e.getMessage(),e);
  501.                 }
  502.                 if(ocspValidator!=null) {
  503.                     this.ocspValidator = ocspValidator;
  504.                     GestoreOCSPValidator gOcspValidator = (GestoreOCSPValidator) ocspValidator;
  505.                     if(gOcspValidator.getOcspConfig()!=null) {
  506.                         crlByOcsp = gOcspValidator.getOcspConfig().isCrl();
  507.                     }
  508.                 }
  509.             }
  510.             
  511.             if(crlByOcsp) {
  512.                 // la validazione crl viene fatta tramite tool ocsp
  513.                 msgCtx.put(SecurityConstants.ENABLE_REVOCATION, SecurityConstants.FALSE);
  514.                 interceptor.setProperty(SecurityConstants.ENABLE_REVOCATION, SecurityConstants.FALSE);
  515.             }
  516.         }
  517.         
  518.         if(samlSigned && !crlByOcsp && this.trustStore!=null && pTrustStore!=null) {
  519.             String trustStoreCRLs = null;
  520.             try {
  521.                 trustStoreCRLs = pTrustStore.getProperty(prefixTrustStore + Merlin.X509_CRL_FILE);
  522.                 if(trustStoreCRLs!=null) {
  523.                     trustStoreCRLs = trustStoreCRLs.trim();
  524.                     this.crlX509 = GestoreKeystoreCache.getCRLCertstore(requestInfo, trustStoreCRLs);
  525.                 }
  526.             }catch(Exception e) {
  527.                 throw new SecurityException("[Truststore-CRLs] '"+trustStoreCRLs+"': "+e.getMessage(),e);
  528.             }
  529.         }
  530.     }

  532.     private void preprocessMultipropFile(MessageSecurityContext wssContext,SoapMessage msgCtx,Map<String,Object> wssIncomingProperties, RequestInfo requestInfo,org.openspcoop2.utils.Map<Object> ctx) throws FileNotFoundException, UtilsException, SecurityException, URISyntaxException {

  534.         Properties pTrustStoreSignatureVerification = null;
  535.         
  536.         String signatureCrls = null;
  537.         for (Map.Entry<String,Object> entry : wssIncomingProperties.entrySet()) {
  538.             if(SecurityConstants.SIGNATURE_CRL.equals(entry.getKey())) {
  539.                 signatureCrls = (String) entry.getValue();
  540.                 break;
  541.             }
  542.         }
  543.         String signatureCrlsValidateOnlyEndEntity = null;
  544.         if(signatureCrls!=null) {
  545.             for (Map.Entry<String,Object> entry : wssIncomingProperties.entrySet()) {
  546.                 if(SecurityConstants.SIGNATURE_CRL_VALIDATE_ONLY_END_ENTITY.equals(entry.getKey())) {
  547.                     signatureCrlsValidateOnlyEndEntity = (String) entry.getValue();
  548.                     break;
  549.                 }
  550.             }
  551.         }
  552.         
  553.         String forceDecryptionUser = null;
  554.         
  555.         for (Map.Entry<String,Object> entry : wssIncomingProperties.entrySet()) {
  556.             String key = entry.getKey();
  557.             if(SecurityConstants.SIGNATURE_TRUSTSTORE_PROPERTY_FILE.equals(key)) {
  558.                 Object o = wssIncomingProperties.get(key);
  559.                 if(o instanceof String) {
  560.                     String path = (String) o;
  561.                     MerlinTruststore merlinTruststore = GestoreKeystoreCache.getMerlinTruststore(requestInfo, path);
  562.                     
  563.                     pTrustStoreSignatureVerification = new Properties();
  564.                     pTrustStoreSignatureVerification.put(KeystoreConstants.PROPERTY_TRUSTSTORE_PATH, merlinTruststore.getPathStore());
  565.                     pTrustStoreSignatureVerification.put(KeystoreConstants.PROPERTY_TRUSTSTORE_PASSWORD, merlinTruststore.getPasswordStore());
  566.                     pTrustStoreSignatureVerification.put(KeystoreConstants.PROPERTY_TRUSTSTORE_TYPE, merlinTruststore.getTipoStore());
  567.                     pTrustStoreSignatureVerification.put(KeystoreConstants.PROPERTY_PROVIDER, KeystoreConstants.PROVIDER_GOVWAY);
  568.                     if(signatureCrls!=null) {
  569.                         pTrustStoreSignatureVerification.put(KeystoreConstants.PROPERTY_CRL, signatureCrls);
  570.                         if(signatureCrlsValidateOnlyEndEntity!=null) {
  571.                             pTrustStoreSignatureVerification.put(KeystoreConstants.PROPERTY_CRL_VALIDATE_ONLY_END_ENTITY, signatureCrlsValidateOnlyEndEntity);
  572.                         }
  573.                     }
  574.                 }
  575.             }
  576.             else if(SecurityConstants.DECRYPTION_MULTI_PROPERTY_FILE.equals(key)) {
  577.                 EncryptionBean bean = KeystoreUtils.getReceiverEncryptionBean(wssContext, ctx);
  578.                 if(bean.getMultiKeystore()==null) {
  579.                     throw new SecurityException("Multiproperty config not exists");
  580.                 }
  581.                 String keyAlias = bean.getUser();
  582.                 String internalAlias = bean.getMultiKeystore().getInternalConfigAlias(keyAlias);
  583.                 Properties p = new Properties();
  584.                 p.put(KeystoreConstants.PROPERTY_KEYSTORE_PATH, bean.getMultiKeystore().getKeystorePath(internalAlias));
  585.                 p.put(KeystoreConstants.PROPERTY_KEYSTORE_PASSWORD, bean.getMultiKeystore().getKeystorePassword(internalAlias));
  586.                 p.put(KeystoreConstants.PROPERTY_KEYSTORE_TYPE, bean.getMultiKeystore().getKeystoreType(internalAlias));
  587.                 p.put(KeystoreConstants.PROPERTY_PROVIDER, KeystoreConstants.PROVIDER_GOVWAY);
  588.                 p.put(KeystoreConstants.PROPERTY_REQUEST_INFO, requestInfo);
  589.                 String id = SecurityConstants.DECRYPTION_PROPERTY_REF_ID +"_"+IDUtilities.getUniqueSerialNumber("wssSecurity.setOutgoingProperties");
  590.                 msgCtx.put(SecurityConstants.DECRYPTION_PROPERTY_REF_ID , id);
  591.                 msgCtx.put(id, p);
  592.                 
  593.                 HashMap<String, String> mapAliasToPassword = new HashMap<>();
  594.                 String password = bean.getPassword();
  595.                 msgCtx.put(SecurityConstants.DECRYPTION_PASSWORD, bean.getPassword());
  596.                 mapAliasToPassword.put(keyAlias, password);
  597.                 CallbackHandler pwCallbackHandler = MessageSecurityContext.newCallbackHandler(mapAliasToPassword);
  598.                 msgCtx.put(SecurityConstants.PASSWORD_CALLBACK_REF, pwCallbackHandler);
  599.                 
  600.                 forceDecryptionUser = keyAlias;
  601.             }
  602.         }
  603.         
  604.         if(pTrustStoreSignatureVerification!=null) {
  605.             wssIncomingProperties.put(SecurityConstants.SIGNATURE_VERIFICATION_PROPERTY_REF_ID, pTrustStoreSignatureVerification);
  606.             if(signatureCrls!=null) {
  607.                 wssIncomingProperties.put(SecurityConstants.ENABLE_REVOCATION, SecurityConstants.TRUE);
  608.             }
  609.         }
  610.         
  611.         if(forceDecryptionUser!=null) {
  612.             wssIncomingProperties.remove(SecurityConstants.DECRYPTION_USER);
  613.             wssIncomingProperties.put(SecurityConstants.DECRYPTION_USER, forceDecryptionUser);
  614.         }
  615.         
  616.     }
  617.     
  618.     private boolean examineResults(SoapMessage msgCtx, String actor) {
  619.                 
  620.         boolean validateX509 = false;
  621.         
  622.         List<?> results = (List<?>) msgCtx.get(WSHandlerConstants.RECV_RESULTS);
  623.         //System.out.println("Potential number of usernames: " + results.size());
  624.         for (int i = 0; results != null && i < results.size(); i++) {
  625.             //System.out.println("RESULT["+i+"]: "+results.get(i).getClass().getName());
  626.             WSHandlerResult hResult = (WSHandlerResult)results.get(i);
  627.             //System.out.println("RESULT["+i+"] actor: "+hResult.getActor());
  628.             
  629.             boolean actorCompatibile = false;
  630.             if(actor==null) {
  631.                 actorCompatibile = hResult.getActor()==null;
  632.             }
  633.             else {
  634.                 actorCompatibile = actor.equals(hResult.getActor());
  635.             }
  636.             
  637.             if(actorCompatibile) {
  638.                 
  639.                 //System.out.println("RESULT["+i+"] ESAMINO SENZA ["+actor+"]");
  640.                 
  641.                 List<WSSecurityEngineResult> hResults = hResult.getResults();
  642.                 for (int j = 0; j < hResults.size(); j++) {
  643.                     WSSecurityEngineResult eResult = hResults.get(j);
  644.                     
  645.                     /*
  646.                     Iterator<String> resultIt = eResult.keySet().iterator();
  647.                     while (resultIt.hasNext()) {
  648.                         String resultItKey = (String) resultIt.next();
  649.                         Object resultItObject = eResult.get(resultItKey);
  650.                         System.out.println("RESULT-INTERNAL ["+i+"]["+j+"] ["+resultItKey+"]["+resultItObject+"]["+(resultItObject!=null ? resultItObject.getClass().getName() : "n.d.")+"]");
  651.                     }*/
  652.                     
  653.                     int actionGet = ((java.lang.Integer)  eResult.get(WSSecurityEngineResult.TAG_ACTION)).intValue();
  654.                     
  655.                     // An encryption or timestamp action does not have an associated principal,
  656.                     // only Signature and UsernameToken actions return a principal
  657.                     if ((actionGet == WSConstants.SIGN) || 
  658.                             (actionGet == WSConstants.UT) || 
  659.                             (actionGet == WSConstants.UT_SIGN) || 
  660.                             (actionGet == WSConstants.ST_SIGNED)) {
  661.                         
  662.                         Object oPrincipal = eResult.get(WSSecurityEngineResult.TAG_PRINCIPAL);
  663.                         if(oPrincipal!=null && oPrincipal instanceof Principal) {
  664.                             Principal principal =  (Principal) oPrincipal;
  665.                             if(principal!=null) {
  666.                                 this.certificate = principal.getName();
  667.                             }
  668.                             if(oPrincipal instanceof org.apache.wss4j.common.principal.SAMLTokenPrincipalImpl) {
  669.                                 org.apache.wss4j.common.principal.SAMLTokenPrincipalImpl samlPrincipal = (org.apache.wss4j.common.principal.SAMLTokenPrincipalImpl) oPrincipal;
  670.                                 if(samlPrincipal.getToken()!=null) {
  671.                                     if(samlPrincipal.getToken().getSignatureKeyInfo()!=null) {
  672.                                         if(samlPrincipal.getToken().getSignatureKeyInfo().getCerts()!=null) {
  673.                                             if(this.x509Certificates==null) {
  674.                                                 this.x509Certificates = samlPrincipal.getToken().getSignatureKeyInfo().getCerts();
  675.                                             }
  676.                                         }
  677.                                         else if(samlPrincipal.getToken().getSignatureKeyInfo().getPublicKey()!=null) {
  678.                                             if(this.x509Certificate==null && this.trustStore!=null) {
  679.                                                 try {
  680.                                                     Certificate c = this.trustStore.getCertificateByPublicKey(samlPrincipal.getToken().getSignatureKeyInfo().getPublicKey());
  681.                                                     if(c!=null && (c instanceof X509Certificate)) {
  682.                                                         this.x509Certificate = (X509Certificate) c;
  683.                                                         validateX509 = true; // in saml handler non viene validato il certificato rispetto alla crl
  684.                                                     }
  685.                                                 }catch(Throwable t) {
  686.                                                     // ignore
  687.                                                 }
  688.                                             }
  689.                                         }
  690.                                     }
  691.                                 }
  692.                             }
  693.                         }
  694.     
  695.                         Object oX509Certificate = eResult.get(WSSecurityEngineResult.TAG_X509_CERTIFICATE);
  696.                         if(oX509Certificate!=null && oX509Certificate instanceof X509Certificate) {
  697.                             this.x509Certificate = (X509Certificate) oX509Certificate;
  698.                             if(this.x509Certificate!=null) {
  699.                                 this.publicKey = this.x509Certificate.getPublicKey();
  700.                             }
  701.                         }
  702.                             
  703.                         Object oListX509Certificates = eResult.get(WSSecurityEngineResult.TAG_X509_CERTIFICATES);
  704.                         if(oListX509Certificates!=null && oListX509Certificates instanceof X509Certificate []){
  705.                             this.x509Certificates = (X509Certificate []) oListX509Certificates;
  706.                             
  707.                             /*
  708.                             if(this.x509Certificates!=null && this.x509Certificates.length>0) {
  709.                                 System.out.println("CERTS: "+this.x509Certificates.length);
  710.                                 int index = 0;
  711.                                 for (X509Certificate X509Certificate : this.x509Certificates) {
  712.                                     System.out.println("CERT["+index+"]: "+X509Certificate.getSubjectX500Principal().toString());   
  713.                                     index ++;
  714.                                 }
  715.                             }
  716.                             */
  717.                             
  718.                         }
  719.                         
  720.                         Object oX509ReferenceType = eResult.get(WSSecurityEngineResult.TAG_X509_REFERENCE_TYPE);
  721.                         if(oX509ReferenceType!=null && oX509ReferenceType instanceof STRParser.REFERENCE_TYPE) {
  722.                             this.x509ReferenceType = (STRParser.REFERENCE_TYPE) oX509ReferenceType;
  723.                             
  724.                             //System.out.println("REFERENCE TYPE: "+this.x509ReferenceType);
  725.                         }
  726.                         
  727.                         Object oSignatureRefs = eResult.get(WSSecurityEngineResult.TAG_DATA_REF_URIS);
  728.                         if(oSignatureRefs!=null && oSignatureRefs instanceof List<?>) {
  729.                             List<WSDataRef> l = new ArrayList<WSDataRef>();
  730.                             List<?> lRefs = (List<?>) oSignatureRefs;
  731.                             for (Object oRef : lRefs) {
  732.                                 if(oRef!=null && oRef instanceof WSDataRef) {
  733.                                     l.add((WSDataRef)oRef);
  734.                                 }
  735.                             }
  736.                             if(!l.isEmpty()) {
  737.                                 this.signatureRefs = l;
  738.                             }
  739.                         }
  740.                     }
  741.                     
  742.                     if( actionGet == WSConstants.ENCR ) {
  743.                         
  744.                         Object oEncryptionRefs = eResult.get(WSSecurityEngineResult.TAG_DATA_REF_URIS);
  745.                         if(oEncryptionRefs!=null && oEncryptionRefs instanceof List<?>) {
  746.                             List<WSDataRef> l = new ArrayList<WSDataRef>();
  747.                             List<?> lRefs = (List<?>) oEncryptionRefs;
  748.                             for (Object oRef : lRefs) {
  749.                                 if(oRef!=null && oRef instanceof WSDataRef) {
  750.                                     l.add((WSDataRef)oRef);
  751.                                 }
  752.                             }
  753.                             if(!l.isEmpty()) {
  754.                                 this.encryptionRefs = l;
  755.                             }
  756.                         }
  757.                         
  758.                     }
  759.                     
  760.                     if( actionGet == WSConstants.TS ) {
  761.                         
  762.                         Object oTimestamp = eResult.get(WSSecurityEngineResult.TAG_TIMESTAMP);
  763.                         if(oTimestamp!=null && oTimestamp instanceof Timestamp) {
  764.                             this.timestamp =  (Timestamp) oTimestamp;
  765.                         }
  766.                         
  767.                     }
  768.                     
  769.                     if( actionGet == WSConstants.ST_SIGNED ) {
  770.                         
  771.                     }
  772.                     
  773.                 }
  774.                 
  775.             }

  777.         }

  779.         /*
  780.         String key = "org.apache.cxf.headers.Header.list";
  781.         if(msgCtx.containsKey(key)) {
  782.             Object o = msgCtx.get(key);
  783.             if(o instanceof List<?> ) {
  784.                 List<?> l = (List<?>) o;
  785.                 System.out.println("SIZE ["+l.size()+"]");
  786.                 if(!l.isEmpty()) {
  787.                     int index = 0;
  788.                     for (Object entry : l) {
  789.                         if(entry!=null) {
  790.                             System.out.println("ENTRY ["+index+"]: "+entry.getClass().getName());
  791.                             if(entry instanceof org.apache.cxf.binding.soap.SoapHeader) {
  792.                                 org.apache.cxf.binding.soap.SoapHeader soapHdr = (org.apache.cxf.binding.soap.SoapHeader) entry;
  793.                                 System.out.println("HDR ("+soapHdr.getActor()+") ("+soapHdr.getObject().getClass().getName()+"): "+soapHdr.getName());
  794.                             }
  795.                             
  796.                         }
  797.                         index++;
  798.                     }
  799.                 }
  800.             }
  801.         }
  802.         */
  803.         
  804.         return validateX509;
  805.     }
  806.     

  808.     @Override
  809.     public List<Reference> getDirtyElements(
  810.             org.openspcoop2.security.message.MessageSecurityContext messageSecurityContext,
  811.             OpenSPCoop2SoapMessage message) throws SecurityException {
  812.         return WSSUtilities.getDirtyElements(messageSecurityContext, message);
  813.     }

  815.     @Override
  816.     public Map<QName, QName> checkEncryptSignatureParts(
  817.             org.openspcoop2.security.message.MessageSecurityContext messageSecurityContext,
  818.             List<Reference> elementsToClean, OpenSPCoop2SoapMessage message,
  819.             List<SubErrorCodeSecurity> codiciErrore) throws SecurityException {
  820.         return MessageUtilities.checkEncryptSignatureParts(messageSecurityContext, elementsToClean, message, codiciErrore, SecurityConstants.QNAME_WSS_ELEMENT_SECURITY);
  821.     }

  823.     @Override
  824.     public void checkEncryptionPartElements(Map<QName, QName> notResolved,
  825.             OpenSPCoop2SoapMessage message,
  826.             List<SubErrorCodeSecurity> erroriRilevati) throws SecurityException {
  827.         MessageUtilities.checkEncryptionPartElements(notResolved, message, erroriRilevati);
  828.     }

  830.     @Override
  831.     public void cleanDirtyElements(
  832.             org.openspcoop2.security.message.MessageSecurityContext messageSecurityContext,
  833.             OpenSPCoop2SoapMessage message, List<Reference> elementsToClean,
  834.             boolean detachHeaderWSSecurity, boolean removeAllIdRef)
  835.             throws SecurityException {
  836.         WSSUtilities.cleanDirtyElements(messageSecurityContext, message, elementsToClean,detachHeaderWSSecurity,removeAllIdRef);
  837.         
  838.     }
  839. }
Created with JaCoCo 0.8.8.202204050719