GestoreTokenAttributeAuthorityUtilities.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it).
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.pdd.core.token;

  23. import java.io.ByteArrayOutputStream;
  24. import java.net.URI;
  25. import java.security.cert.Certificate;
  26. import java.security.cert.X509Certificate;
  27. import java.text.SimpleDateFormat;
  28. import java.util.ArrayList;
  29. import java.util.Date;
  30. import java.util.Enumeration;
  31. import java.util.HashMap;
  32. import java.util.List;
  33. import java.util.Map;
  34. import java.util.Properties;

  36. import javax.servlet.http.HttpServletRequest;

  38. import org.apache.cxf.rs.security.jose.jwk.JsonWebKeys;
  39. import org.openspcoop2.core.commons.DBUtils;
  40. import org.openspcoop2.core.config.AttributeAuthority;
  41. import org.openspcoop2.core.config.InvocazioneCredenziali;
  42. import org.openspcoop2.core.config.PortaApplicativa;
  43. import org.openspcoop2.core.config.PortaDelegata;
  44. import org.openspcoop2.core.config.Proprieta;
  45. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  46. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  47. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  48. import org.openspcoop2.core.constants.CostantiConnettori;
  49. import org.openspcoop2.core.constants.TipiConnettore;
  50. import org.openspcoop2.core.constants.TransferLengthModes;
  51. import org.openspcoop2.core.id.IDGenericProperties;
  52. import org.openspcoop2.core.id.IDServizio;
  53. import org.openspcoop2.core.id.IDSoggetto;
  54. import org.openspcoop2.core.mvc.properties.provider.ProviderException;
  55. import org.openspcoop2.core.mvc.properties.provider.ProviderValidationException;
  56. import org.openspcoop2.message.OpenSPCoop2Message;
  57. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  58. import org.openspcoop2.message.OpenSPCoop2MessageParseResult;
  59. import org.openspcoop2.message.constants.MessageType;
  60. import org.openspcoop2.message.constants.ServiceBinding;
  61. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  62. import org.openspcoop2.pdd.config.CostantiProprieta;
  63. import org.openspcoop2.pdd.config.ForwardProxy;
  64. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  65. import org.openspcoop2.pdd.core.PdDContext;
  66. import org.openspcoop2.pdd.core.connettori.ConnettoreBaseHTTP;
  67. import org.openspcoop2.pdd.core.connettori.ConnettoreHTTP;
  68. import org.openspcoop2.pdd.core.connettori.ConnettoreHTTPS;
  69. import org.openspcoop2.pdd.core.connettori.ConnettoreMsg;
  70. import org.openspcoop2.pdd.core.controllo_traffico.PolicyTimeoutConfig;
  71. import org.openspcoop2.pdd.core.dynamic.DynamicMapBuilderUtils;
  72. import org.openspcoop2.pdd.core.dynamic.DynamicUtils;
  73. import org.openspcoop2.pdd.core.dynamic.ErrorHandler;
  74. import org.openspcoop2.pdd.core.dynamic.MessageContent;
  75. import org.openspcoop2.pdd.core.dynamic.Template;
  76. import org.openspcoop2.pdd.core.token.attribute_authority.AttributeAuthorityDynamicParameters;
  77. import org.openspcoop2.pdd.core.token.attribute_authority.BasicRetrieveAttributeAuthorityResponseParser;
  78. import org.openspcoop2.pdd.core.token.attribute_authority.EsitoRecuperoAttributi;
  79. import org.openspcoop2.pdd.core.token.attribute_authority.IRetrieveAttributeAuthorityResponseParser;
  80. import org.openspcoop2.pdd.core.token.attribute_authority.InformazioniAttributi;
  81. import org.openspcoop2.pdd.core.token.attribute_authority.PolicyAttributeAuthority;
  82. import org.openspcoop2.pdd.core.token.attribute_authority.RequiredAttributes;
  83. import org.openspcoop2.pdd.core.token.attribute_authority.pa.EsitoRecuperoAttributiPortaApplicativa;
  84. import org.openspcoop2.pdd.core.token.attribute_authority.pd.EsitoRecuperoAttributiPortaDelegata;
  85. import org.openspcoop2.pdd.core.token.parser.Claims;
  86. import org.openspcoop2.pdd.services.connector.FormUrlEncodedHttpServletRequest;
  87. import org.openspcoop2.protocol.sdk.Busta;
  88. import org.openspcoop2.protocol.sdk.Context;
  89. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  90. import org.openspcoop2.protocol.sdk.state.IState;
  91. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  92. import org.openspcoop2.security.SecurityException;
  93. import org.openspcoop2.security.keystore.CRLCertstore;
  94. import org.openspcoop2.security.keystore.JWKSetStore;
  95. import org.openspcoop2.security.keystore.KeyPairStore;
  96. import org.openspcoop2.security.keystore.MerlinKeystore;
  97. import org.openspcoop2.security.keystore.cache.GestoreKeystoreCache;
  98. import org.openspcoop2.security.keystore.cache.GestoreOCSPResource;
  99. import org.openspcoop2.security.keystore.cache.GestoreOCSPValidator;
  100. import org.openspcoop2.security.message.constants.SecurityConstants;
  101. import org.openspcoop2.utils.LoggerBuffer;
  102. import org.openspcoop2.utils.UtilsException;
  103. import org.openspcoop2.utils.certificate.JWKSet;
  104. import org.openspcoop2.utils.certificate.KeyStore;
  105. import org.openspcoop2.utils.certificate.KeystoreType;
  106. import org.openspcoop2.utils.certificate.byok.BYOKProvider;
  107. import org.openspcoop2.utils.certificate.byok.BYOKRequestParams;
  108. import org.openspcoop2.utils.date.DateManager;
  109. import org.openspcoop2.utils.date.DateUtils;
  110. import org.openspcoop2.utils.id.UniqueIdentifierManager;
  111. import org.openspcoop2.utils.io.Base64Utilities;
  112. import org.openspcoop2.utils.json.JSONUtils;
  113. import org.openspcoop2.utils.properties.PropertiesUtilities;
  114. import org.openspcoop2.utils.security.CertificateValidityCheck;
  115. import org.openspcoop2.utils.security.JOSESerialization;
  116. import org.openspcoop2.utils.security.JWSOptions;
  117. import org.openspcoop2.utils.security.JWTOptions;
  118. import org.openspcoop2.utils.security.JsonSignature;
  119. import org.openspcoop2.utils.security.JsonVerifySignature;
  120. import org.openspcoop2.utils.security.JwtHeaders;
  121. import org.openspcoop2.utils.transport.TransportRequestContext;
  122. import org.openspcoop2.utils.transport.TransportUtils;
  123. import org.openspcoop2.utils.transport.http.HttpConstants;
  124. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  125. import org.openspcoop2.utils.transport.http.HttpResponse;
  126. import org.openspcoop2.utils.transport.http.HttpServletTransportRequestContext;
  127. import org.openspcoop2.utils.transport.http.IOCSPValidator;
  128. import org.slf4j.Logger;

  130. import com.fasterxml.jackson.databind.JsonNode;
  131. import com.fasterxml.jackson.databind.node.ObjectNode;

  133. /**     
  134.  * GestoreTokenAttributeAuthorityUtilities
  135.  *
  136.  * @author Poli Andrea (poli@link.it)
  137.  * @author $Author$
  138.  * @version $Rev$, $Date$
  139.  */
  140. public class GestoreTokenAttributeAuthorityUtilities {

  142.     private GestoreTokenAttributeAuthorityUtilities(){}
  143.         
  144.     static EsitoRecuperoAttributi readAttributes(Logger log, PolicyAttributeAuthority policyAttributeAuthority,
  145.             IProtocolFactory<?> protocolFactory,
  146.             AttributeAuthorityDynamicParameters dynamicParameters,
  147.             String request, boolean portaDelegata, Context context,
  148.             Busta busta, String idModulo, PortaApplicativa pa, PortaDelegata pd,
  149.             IState state,
  150.             IDSoggetto idDominio, IDServizio idServizio,
  151.             RequestInfo requestInfo) {
  152.         EsitoRecuperoAttributi esitoRecuperoAttributi = null;
  153.         if(portaDelegata) {
  154.             esitoRecuperoAttributi = new EsitoRecuperoAttributiPortaDelegata();
  155.         }
  156.         else {
  157.             esitoRecuperoAttributi = new EsitoRecuperoAttributiPortaApplicativa();
  158.         }
  159.         
  160.         esitoRecuperoAttributi.setTokenInternalError();
  161.         
  162.         try{            
  163.             String detailsError = null;
  164.             InformazioniAttributi informazioniAttributi = null;
  165.             Exception eProcess = null;
  166.             
  167.             IRetrieveAttributeAuthorityResponseParser tokenParser = policyAttributeAuthority.getRetrieveAttributeAuthorityResponseParser(log);
  168.             
  169.             HttpResponse httpResponse = null;
  170.             Integer httpResponseCode = null;
  171.             byte[] risposta = null;
  172.             try {
  173.                 httpResponse = http(log, policyAttributeAuthority,
  174.                         protocolFactory,
  175.                         dynamicParameters,
  176.                         request,
  177.                         state, portaDelegata, idModulo, pa, pd,
  178.                         idDominio, idServizio,
  179.                         busta, requestInfo);
  180.                 risposta = httpResponse.getContent();
  181.                 httpResponseCode = httpResponse.getResultHTTPOperation();
  182.             }catch(Exception e) {
  183.                 detailsError = "(Errore di Connessione) "+ e.getMessage();
  184.                 eProcess = e;
  185.             }
  186.             
  187.             if(detailsError==null) {
  188.                 
  189.                 String decodedPayload = null;
  190.                 byte[] decodedPayloadAsBytes = null;
  191.                 if(policyAttributeAuthority.isResponseJws()) {
  192.                     // JWS Compact              
  193.                     JsonVerifySignature jsonCompactVerify = null;
  194.                     try {
  195.                         JWTOptions options = new JWTOptions(JOSESerialization.COMPACT);
  196.                         Properties p = policyAttributeAuthority.getProperties().get(org.openspcoop2.pdd.core.token.attribute_authority.Costanti.POLICY_VALIDAZIONE_JWS_VERIFICA_PROP_REF_ID);
  197.                         TokenUtilities.injectJOSEConfig(p, policyAttributeAuthority, null,  
  198.                                 busta, idDominio, idServizio,
  199.                                 context, log,
  200.                                 requestInfo, state, portaDelegata);
  201.                         
  202.                         // serve per leggere il keystore dalla cache
  203.                         TokenKeystoreInjectUtilities inject = new TokenKeystoreInjectUtilities(log, requestInfo ,
  204.                                 protocolFactory, 
  205.                                 context, state, busta);
  206.                         inject.initAttributeAuthorityValidazioneRispostaJwt(policyAttributeAuthority.getName(), portaDelegata, pd, pa, p);
  207.                         inject.inject(p);
  208.                         
  209.                         String aliasMode = p.getProperty(SecurityConstants.JOSE_KEYSTORE_KEY_ALIAS+".mode"); 
  210.                         if(aliasMode!=null && 
  211.                                 (
  212.                                         aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5C)
  213.                                         ||
  214.                                         aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5T256)
  215.                                         ||
  216.                                         aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5C_X5T256)
  217.                                         ||
  218.                                         aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_KID)
  219.                                         ||
  220.                                         aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5U)
  221.                                 )
  222.                             ) {
  223.                             
  224.                             options.setPermitUseHeaderX5C(aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5C) || aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5C_X5T256));
  225.                             // se lo si vuole usare utilizzare la vecchia modalità alias special case
  226.                             /** options.setPermitUseHeaderX5T(aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5T256) || aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5C_X5T256)); */
  227.                             options.setPermitUseHeaderX5T_256(aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5T256) || aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5C_X5T256));
  228.                             options.setPermitUseHeaderKID(aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_KID));
  229.                             options.setPermitUseHeaderX5U(aliasMode.equals(Costanti.ID_VALIDAZIONE_JWT_TRUSTSTORE_TYPE_SELECT_CERTIFICATE_VALUE_X5U));
  230.                                                         
  231.                             if(p.containsKey(SecurityConstants.JOSE_KEYSTORE)) {
  232.                                 Object oKeystore = p.get(SecurityConstants.JOSE_KEYSTORE);
  233.                                 if(oKeystore instanceof java.security.KeyStore) {
  234.                                     java.security.KeyStore keystore = (java.security.KeyStore) oKeystore;
  235.                                     jsonCompactVerify = new JsonVerifySignature(keystore, options);
  236.                                     
  237.                                     CertificateValidityCheck validityCheck = OpenSPCoop2Properties.getInstance().getGestioneAttributeAuthorityValidityCheck();
  238.                                     List<Proprieta> proprieta = null;
  239.                                     if(pa!=null) {
  240.                                         proprieta = pa.getProprietaList();
  241.                                     }
  242.                                     else if(pd!=null) {
  243.                                         proprieta = pd.getProprietaList();
  244.                                     }
  245.                                     validityCheck = CostantiProprieta.getAttributeAuthorityCertificateValidityCheck(proprieta, validityCheck);
  246.                                     jsonCompactVerify.setValidityCheck(validityCheck);
  247.                                     
  248.                                     String signatureOCSP = policyAttributeAuthority.getResponseJwsOcspPolicy();
  249.                                     String signatureCRL = policyAttributeAuthority.getResponseJwsCrl();
  250.                                     
  251.                                     boolean crlByOcsp = false;
  252.                                     if(keystore!=null && signatureOCSP!=null && !"".equals(signatureOCSP)) {
  253.                                         LoggerBuffer lb = new LoggerBuffer();
  254.                                         lb.setLogDebug(log);
  255.                                         lb.setLogError(log);
  256.                                         GestoreOCSPResource ocspResourceReader = new GestoreOCSPResource(requestInfo);
  257.                                         IOCSPValidator ocspValidator = null;
  258.                                         try {
  259.                                             org.openspcoop2.utils.certificate.KeyStore trustStore = new org.openspcoop2.utils.certificate.KeyStore(keystore);
  260.                                             ocspValidator = new GestoreOCSPValidator(requestInfo, lb, 
  261.                                                     trustStore,
  262.                                                     signatureCRL, 
  263.                                                     signatureOCSP, 
  264.                                                     ocspResourceReader);
  265.                                         }catch(Exception e){
  266.                                             throw new TokenException("ocsp initialization (policy:'"+signatureOCSP+"') failed: "+e.getMessage(),e);
  267.                                         }
  268.                                         if(ocspValidator!=null) {
  269.                                             jsonCompactVerify.setOcspValidatorX509(ocspValidator);
  270.                                             GestoreOCSPValidator gOcspValidator = (GestoreOCSPValidator) ocspValidator;
  271.                                             if(gOcspValidator.getOcspConfig()!=null) {
  272.                                                 crlByOcsp = gOcspValidator.getOcspConfig().isCrl();
  273.                                             }
  274.                                         }
  275.                                     }
  276.                                     
  277.                                     if(signatureCRL!=null && !"".equals(signatureCRL) && !crlByOcsp) {
  278.                                         CRLCertstore crlCertstore = GestoreKeystoreCache.getCRLCertstore(requestInfo, signatureCRL);
  279.                                         if(crlCertstore==null) {
  280.                                             throw new TokenException("Process CRL '"+signatureCRL+"' failed");
  281.                                         }
  282.                                         jsonCompactVerify.setCrlX509(crlCertstore.getCertStore());
  283.                                     }

  285.                                 }
  286.                             }
  287.                             else if(p.containsKey(SecurityConstants.JOSE_KEYSTORE_JWKSET)) {
  288.                                 Object oKeystore = p.get(SecurityConstants.JOSE_KEYSTORE_JWKSET);
  289.                                 if(oKeystore instanceof String) {
  290.                                     String keystore = (String) oKeystore;
  291.                                     JsonWebKeys jwksKeystore = new JWKSet(keystore).getJsonWebKeys();
  292.                                     jsonCompactVerify = new JsonVerifySignature(jwksKeystore, options);
  293.                                 }
  294.                             }
  295.                         }
  296.                                             
  297.                         if(jsonCompactVerify==null) {
  298.                             jsonCompactVerify = new JsonVerifySignature(p, options);
  299.                         }
  300.                         
  301.                         jsonCompactVerify.setJksPasswordRequired(DBUtils.isTruststoreJksPasswordRequired());
  302.                         jsonCompactVerify.setPkcs12PasswordRequired(DBUtils.isTruststorePkcs12PasswordRequired());
  303.                         
  304.                         if(jsonCompactVerify.verify(new String(risposta))) {
  305.                             if(tokenParser instanceof BasicRetrieveAttributeAuthorityResponseParser) {
  306.                                 decodedPayload = jsonCompactVerify.getDecodedPayload(); 
  307.                             }
  308.                             else {
  309.                                 decodedPayloadAsBytes = jsonCompactVerify.getDecodedPayloadAsByte();
  310.                             }
  311.                         }
  312.                         else {
  313.                             detailsError = "Risposta non valida";
  314.                         }
  315.                     }catch(Exception e) {
  316.                         detailsError = "Risposta non valida: "+e.getMessage();
  317.                         eProcess = e;
  318.                     }
  319.                 }
  320.                 
  321.                 if(detailsError==null) {
  322.                     try {
  323.                         if(tokenParser instanceof BasicRetrieveAttributeAuthorityResponseParser) {
  324.                             informazioniAttributi = new InformazioniAttributi(httpResponseCode, policyAttributeAuthority.getName(),
  325.                                     decodedPayload!=null ? decodedPayload : new String(risposta),
  326.                                     tokenParser);       
  327.                         }
  328.                         else {
  329.                             informazioniAttributi = new InformazioniAttributi(httpResponseCode, policyAttributeAuthority.getName(), 
  330.                                     decodedPayloadAsBytes!=null ? decodedPayloadAsBytes : risposta, 
  331.                                     tokenParser);       
  332.                         }
  333.                     }catch(Exception e) {
  334.                         detailsError = "Risposta del servizio di negoziazione token non valida: "+e.getMessage();
  335.                         eProcess = e;
  336.                     }
  337.                 }
  338.             }
  339.                     
  340.             if(informazioniAttributi!=null && informazioniAttributi.isValid()) {
  341.                 esitoRecuperoAttributi.setTokenValido();
  342.                 esitoRecuperoAttributi.setInformazioniAttributi(informazioniAttributi);
  343.                 esitoRecuperoAttributi.setNoCache(false);
  344.             }
  345.             else {
  346.                 esitoRecuperoAttributi.setTokenValidazioneFallita();
  347.                 esitoRecuperoAttributi.setNoCache(!policyAttributeAuthority.isSaveErrorInCache());
  348.                 esitoRecuperoAttributi.setEccezioneProcessamento(eProcess);
  349.                 if(detailsError!=null) {
  350.                     esitoRecuperoAttributi.setDetails(detailsError);    
  351.                 }
  352.                 else {
  353.                     esitoRecuperoAttributi.setDetails("Attributi non recuperabili");    
  354.                 }   
  355.             }
  356.             
  357.         }catch(Exception e){
  358.             esitoRecuperoAttributi.setTokenInternalError();
  359.             esitoRecuperoAttributi.setDetails(e.getMessage());
  360.             esitoRecuperoAttributi.setEccezioneProcessamento(e);
  361.         }
  362.         
  363.         return esitoRecuperoAttributi;
  364.     }
  365.     
  366.     static String buildCacheKeyRecuperoAttributiPrefix(String nomePolicy, String funzione) {
  367.         StringBuilder bf = new StringBuilder("AttributeAuthority_"+funzione);
  368.         bf.append("_");
  369.         bf.append(nomePolicy);
  370.         bf.append("_");
  371.         return bf.toString();
  372.     }
  373.     static String buildCacheKeyRecuperoAttributi(String nomePolicy, String funzione, boolean portaDelegata,
  374.             AttributeAuthorityDynamicParameters dynamicParameters, String request) {
  375.         StringBuilder bf = new StringBuilder();
  376.         bf.append(buildCacheKeyRecuperoAttributiPrefix(nomePolicy, funzione));
  377.         if(portaDelegata){ // serve per non aver classcast exception nei risultati
  378.             bf.append("PD");
  379.         }
  380.         else {
  381.             bf.append("PA");
  382.         }
  383.         bf.append("_");
  384.         
  385.         String dynamicParametersKeyCache = dynamicParameters.toString("_", true);
  386.         bf.append(dynamicParametersKeyCache);
  387.         bf.append("_");
  388.         
  389.         bf.append(Base64Utilities.encodeAsString(request.getBytes())); // codifico in base64 la richiesta
  390.         return bf.toString();
  391.     }
  392.     
  393.     
  394.     static Map<String, Object> buildDynamicAAMap(OpenSPCoop2Message message, Busta busta, 
  395.             RequestInfo requestInfo, PdDContext pddContext, Logger log,
  396.             String nomeAttributeAuthority,
  397.             org.openspcoop2.pdd.core.token.attribute_authority.AbstractDatiInvocazione datiInvocazione) throws TokenException {
  398.     
  399.         Map<String, Object> dynamicMap = new HashMap<>();
  400.         
  401.         Map<String, List<String>> pTrasporto = null;
  402.         String urlInvocazione = null;
  403.         Map<String, List<String>> pQuery = null;
  404.         Map<String, List<String>> pForm = null;
  405.         if(requestInfo!=null && requestInfo.getProtocolContext()!=null) {
  406.             pTrasporto = requestInfo.getProtocolContext().getHeaders();
  407.             urlInvocazione = requestInfo.getProtocolContext().getUrlInvocazione_formBased();
  408.             pQuery = requestInfo.getProtocolContext().getParameters();
  409.             if(requestInfo.getProtocolContext() instanceof HttpServletTransportRequestContext) {
  410.                 HttpServletTransportRequestContext httpServletContext = requestInfo.getProtocolContext();
  411.                 HttpServletRequest httpServletRequest = httpServletContext.getHttpServletRequest();
  412.                 if(httpServletRequest instanceof FormUrlEncodedHttpServletRequest) {
  413.                     FormUrlEncodedHttpServletRequest formServlet = (FormUrlEncodedHttpServletRequest) httpServletRequest;
  414.                     if(formServlet.getFormUrlEncodedParametersValues()!=null &&
  415.                             !formServlet.getFormUrlEncodedParametersValues().isEmpty()) {
  416.                         pForm = formServlet.getFormUrlEncodedParametersValues();
  417.                     }
  418.                 }
  419.             }
  420.         }
  421.         
  422.         MessageContent messageContent = null;
  423.         try {
  424.             boolean bufferMessageReadOnly =  OpenSPCoop2Properties.getInstance().isReadByPathBufferEnabled();
  425.             if(ServiceBinding.SOAP.equals(message.getServiceBinding())){
  426.                 messageContent = new MessageContent(message.castAsSoap(), bufferMessageReadOnly, pddContext);
  427.             }
  428.             else{
  429.                 if(MessageType.XML.equals(message.getMessageType())){
  430.                     messageContent = new MessageContent(message.castAsRestXml(), bufferMessageReadOnly, pddContext);
  431.                 }
  432.                 else if(MessageType.JSON.equals(message.getMessageType())){
  433.                     messageContent = new MessageContent(message.castAsRestJson(), bufferMessageReadOnly, pddContext);
  434.                 }
  435.             }
  436.         }catch(Exception e) {
  437.             throw new TokenException(e.getMessage(),e);
  438.         }
  439.         
  440.         ErrorHandler errorHandler = new ErrorHandler();
  441.         DynamicUtils.fillDynamicMapRequest(log, dynamicMap, pddContext, urlInvocazione,
  442.                 message,
  443.                 messageContent, 
  444.                 busta, 
  445.                 pTrasporto, 
  446.                 pQuery,
  447.                 pForm,
  448.                 errorHandler);
  449.         
  450.         List<String> listAttributi = null;
  451.         if(datiInvocazione instanceof org.openspcoop2.pdd.core.token.attribute_authority.pa.DatiInvocazionePortaApplicativa) {
  452.             org.openspcoop2.pdd.core.token.attribute_authority.pa.DatiInvocazionePortaApplicativa datiPA = 
  453.                     (org.openspcoop2.pdd.core.token.attribute_authority.pa.DatiInvocazionePortaApplicativa) datiInvocazione;
  454.             if(datiPA.getPa()!=null && datiPA.getPa().sizeAttributeAuthorityList()>0) {
  455.                 for (AttributeAuthority aa : datiPA.getPa().getAttributeAuthorityList()) {
  456.                     if(nomeAttributeAuthority.equals(aa.getNome())) {
  457.                         listAttributi = aa.getAttributoList();
  458.                         break;
  459.                     }
  460.                 }
  461.             }
  462.             else if(datiPA.getPd()!=null && datiPA.getPd().sizeAttributeAuthorityList()>0) {
  463.                 for (AttributeAuthority aa : datiPA.getPd().getAttributeAuthorityList()) {
  464.                     if(nomeAttributeAuthority.equals(aa.getNome())) {
  465.                         listAttributi = aa.getAttributoList();
  466.                         break;
  467.                     }
  468.                 }
  469.             }
  470.         }
  471.         else if(datiInvocazione instanceof org.openspcoop2.pdd.core.token.attribute_authority.pd.DatiInvocazionePortaDelegata) {
  472.             org.openspcoop2.pdd.core.token.attribute_authority.pd.DatiInvocazionePortaDelegata datiPD = 
  473.                     (org.openspcoop2.pdd.core.token.attribute_authority.pd.DatiInvocazionePortaDelegata) datiInvocazione;
  474.             if(datiPD.getPd()!=null && datiPD.getPd().sizeAttributeAuthorityList()>0) {
  475.                 for (AttributeAuthority aa : datiPD.getPd().getAttributeAuthorityList()) {
  476.                     if(nomeAttributeAuthority.equals(aa.getNome())) {
  477.                         listAttributi = aa.getAttributoList();
  478.                         break;
  479.                     }
  480.                 }
  481.             }
  482.         }
  483.         
  484.         // Viene messo sempre per facilitare la scrittura delle regole
  485.         if(listAttributi==null) {
  486.             listAttributi = new ArrayList<>();
  487.         }
  488.         /**if(listAttributi!=null && listAttributi.size()>0) {*/
  489.         RequiredAttributes reqAttrs = new RequiredAttributes(listAttributi);
  490.         dynamicMap.put(org.openspcoop2.pdd.core.dynamic.Costanti.MAP_REQUIRED_ATTRIBUTES, reqAttrs);
  491.         dynamicMap.put(org.openspcoop2.pdd.core.dynamic.Costanti.MAP_REQUIRED_ATTRIBUTES.toLowerCase(), reqAttrs);
  492.         
  493.         return dynamicMap;
  494.     }
  495.     
  496.     static String buildDynamicAARequest(ConfigurazionePdDManager configurazionePdDManager,
  497.             IProtocolFactory<?> protocolFactory, RequestInfo requestInfo, 
  498.             PolicyAttributeAuthority policyAttributeAuthority,
  499.             AttributeAuthorityDynamicParameters dynamicParameters,
  500.             boolean addIdAndDate) throws TokenException, UtilsException {
  501.             
  502.         String dynamicContent = policyAttributeAuthority.getRequestDynamicPayload();
  503.         String request = null;
  504.         
  505.         if(policyAttributeAuthority.isRequestDynamicPayloadTemplate() || policyAttributeAuthority.isRequestDynamicPayloadJwt()) {
  506.             if(policyAttributeAuthority.isRequestDynamicPayloadTemplate()) {
  507.                 request = dynamicParameters.getRequestDynamicPayloadTemplate();
  508.             }
  509.             else {
  510.                 request = buildAAJwt(policyAttributeAuthority, dynamicParameters, 
  511.                         protocolFactory, requestInfo, 
  512.                         addIdAndDate);
  513.             }
  514.         }
  515.         else if(policyAttributeAuthority.isRequestDynamicPayloadFreemarkerTemplate()) {
  516.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  517.             try {
  518.                 Template template = configurazionePdDManager.getTemplateAttributeAuthorityRequest(policyAttributeAuthority.getName(), dynamicContent.getBytes(), requestInfo);
  519.                 DynamicUtils.convertFreeMarkerTemplate(template, dynamicParameters.getDynamicMap(), bout);
  520.                 bout.flush();
  521.                 bout.close();
  522.             }catch(Exception e) {
  523.                 throw new TokenException(e.getMessage(),e);
  524.             }
  525.             request = bout.toString();
  526.             
  527.             if(policyAttributeAuthority.isRequestJws()) {
  528.                 request = normalizeJwtPayload(request);
  529.             }
  530.         }
  531.         else if(policyAttributeAuthority.isRequestDynamicPayloadVelocityTemplate()) {
  532.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  533.             try {
  534.                 Template template = configurazionePdDManager.getTemplateAttributeAuthorityRequest(policyAttributeAuthority.getName(), dynamicContent.getBytes(), requestInfo);
  535.                 DynamicUtils.convertVelocityTemplate(template, dynamicParameters.getDynamicMap(), bout);
  536.                 bout.flush();
  537.                 bout.close();
  538.             }catch(Exception e) {
  539.                 throw new TokenException(e.getMessage(),e);
  540.             }
  541.             request = bout.toString();
  542.             
  543.             if(policyAttributeAuthority.isRequestJws()) {
  544.                 request = normalizeJwtPayload(request);
  545.             }
  546.         }
  547.         if(request==null || "".equals(request)) {
  548.             throw new TokenException("Request undefined");
  549.         }
  550.         
  551.         return request;
  552.     }
  553.     
  554.     private static String normalizeJwtPayload(String payload) throws UtilsException {
  555.         JSONUtils jsonUtils = JSONUtils.getInstance(false);
  556.         JsonNode jwtPayload = jsonUtils.getAsNode(payload);
  557.         return jsonUtils.toString(jwtPayload);
  558.     }
  559.     
  560.     private static String buildAAJwt(PolicyAttributeAuthority policyAttributeAuthority, 
  561.             AttributeAuthorityDynamicParameters dynamicParameters,
  562.             IProtocolFactory<?> protocolFactory, RequestInfo requestInfo,
  563.             boolean addIdAndDate) throws TokenException, UtilsException {
  564.         
  565.         // https://datatracker.ietf.org/doc/html/rfc7523
  566.         
  567.         OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  568.         JSONUtils jsonUtils = JSONUtils.getInstance(false);
  569.         
  570.         ObjectNode jwtPayload = jsonUtils.newObjectNode();

  572.         // add iat, nbf, exp
  573.         long nowMs = DateManager.getTimeMillis();
  574.         long nowSeconds = nowMs/1000;
  575.         
  576.         String issuer = dynamicParameters.getIssuer();
  577.         if(issuer==null || "".equals(issuer)) {
  578.             issuer = op2Properties.getIdentitaPortaDefault(protocolFactory!=null ? protocolFactory.getProtocol() : null, requestInfo).getNome();
  579.         }
  580.         jwtPayload.put(Claims.JSON_WEB_TOKEN_RFC_7519_ISSUER, issuer);
  581.         
  582.         String subject = dynamicParameters.getSubject();
  583.         if(subject==null) {
  584.             throw new TokenException("JWT-Subject undefined");
  585.         }
  586.         jwtPayload.put(Claims.JSON_WEB_TOKEN_RFC_7519_SUBJECT, subject);
  587.         
  588.         // The JWT MUST contain an "aud" (audience) claim containing a value that identifies the authorization server as an intended audience. 
  589.         String audience = dynamicParameters.getAudience();
  590.         if(audience==null) {
  591.             throw new TokenException("JWT-Audience undefined");
  592.         }
  593.         jwtPayload.put(Claims.JSON_WEB_TOKEN_RFC_7519_AUDIENCE, audience);
  594.         
  595.         // claims
  596.         String claims = dynamicParameters.getClaims();
  597.         if(claims!=null && !"".equals(claims)) {
  598.             Properties convertTextToProperties = PropertiesUtilities.convertTextToProperties(claims);
  599.             if(convertTextToProperties!=null && !convertTextToProperties.isEmpty()) {
  600.                 Enumeration<Object> keys = convertTextToProperties.keys();
  601.                 while (keys.hasMoreElements()) {
  602.                     String nome = (String) keys.nextElement();
  603.                     if(nome!=null && !"".equals(nome)) {
  604.                         String valore = convertTextToProperties.getProperty(nome);
  605.                         if(valore!=null) {
  606.                             jsonUtils.putValue(jwtPayload, nome, valore);
  607.                         }
  608.                     }
  609.                 }
  610.             }
  611.         }
  612.         
  613.         if(addIdAndDate) {
  614.         
  615.             // The JWT MAY contain an "iat" (issued at) claim that identifies the time at which the JWT was issued. 
  616.             jwtPayload.put(Claims.JSON_WEB_TOKEN_RFC_7519_ISSUED_AT, nowSeconds);
  617.             
  618.             // The JWT MAY contain an "nbf" (not before) claim that identifies the time before which the token MUST NOT be accepted for processing.
  619.             jwtPayload.put(Claims.JSON_WEB_TOKEN_RFC_7519_NOT_TO_BE_USED_BEFORE, nowSeconds);
  620.             
  621.             // The JWT MUST contain an "exp" (expiration time) claim that limits the time window during which the JWT can be used.
  622.             int ttl = -1;
  623.             try {
  624.                 ttl = policyAttributeAuthority.getJwtTtlSeconds();
  625.             }catch(Exception e) {
  626.                 throw new TokenException("Invalid JWT-TimeToLive value: "+e.getMessage(),e);
  627.             }
  628.             long expired = nowSeconds+ttl;
  629.             jwtPayload.put(Claims.JSON_WEB_TOKEN_RFC_7519_EXPIRED, expired);
  630.             
  631.             // The JWT MAY contain a "jti" (JWT ID) claim that provides a unique identifier for the token.
  632.             String uuid = null;
  633.             try {
  634.                 uuid = UniqueIdentifierManager.newUniqueIdentifier().toString();
  635.             }catch(Exception e) {
  636.                 throw new TokenException("Invalid JWT-TimeToLive value: "+e.getMessage(),e);
  637.             }
  638.             jwtPayload.put(Claims.JSON_WEB_TOKEN_RFC_7519_JWT_ID, uuid);
  639.             
  640.         }
  641.         
  642.         return jsonUtils.toString(jwtPayload);
  643.     }
  644.     
  645.     static void validazioneInformazioniAttributiRecuperati(EsitoRecuperoAttributi esitoRecuperoAttributi, PolicyAttributeAuthority policyAttributeAuthority, boolean saveErrorInCache,
  646.             AttributeAuthorityDynamicParameters dynamicParameters) throws TokenException, ProviderException, ProviderValidationException {
  647.         
  648.         Date now = DateManager.getDate();
  649.         
  650.         if(esitoRecuperoAttributi.isValido()) {
  651.             esitoRecuperoAttributi.setDateValide(true); // tanto le ricontrollo adesso
  652.         }
  653.         
  654.         if(esitoRecuperoAttributi.isValido() &&     
  655.             esitoRecuperoAttributi.getInformazioniAttributi().getExp()!=null &&             
  656.             !now.before(esitoRecuperoAttributi.getInformazioniAttributi().getExp())){
  657.             /*
  658.              *  The lifetime in seconds of the access token.  For example, the value "3600" denotes that the access token will
  659.              * expire in one hour from the time the response was generated.
  660.              * If omitted, the authorization server SHOULD provide the expiration time via other means or document the default value. 
  661.              **/
  662.             esitoRecuperoAttributi.setTokenScaduto();
  663.             esitoRecuperoAttributi.setDateValide(false);
  664.             esitoRecuperoAttributi.setDetails("Response attributes expired");
  665.         }
  666.             
  667.         if(esitoRecuperoAttributi.isValido() &&
  668.             esitoRecuperoAttributi.getInformazioniAttributi().getNbf()!=null &&     
  669.             !esitoRecuperoAttributi.getInformazioniAttributi().getNbf().before(now)){
  670.             /*
  671.              *   The "nbf" (not before) claim identifies the time before which the JWT MUST NOT be accepted for processing.  
  672.              **/
  673.             esitoRecuperoAttributi.setTokenNotUsableBefore();
  674.             esitoRecuperoAttributi.setDateValide(false);
  675.             SimpleDateFormat sdf = DateUtils.getDefaultDateTimeFormatter(GestoreToken.DATE_FORMAT);
  676.             esitoRecuperoAttributi.setDetails("Response attributes not usable before "+sdf.format(esitoRecuperoAttributi.getInformazioniAttributi().getNbf()));
  677.         }
  678.         
  679.         if(esitoRecuperoAttributi.isValido() &&
  680.             esitoRecuperoAttributi.getInformazioniAttributi().getIat()!=null) {             
  681.             /*
  682.              *   The "iat" (issued at) claim identifies the time at which the JWT was issued.  This claim can be used to determine the age of the JWT.
  683.              *   The iat Claim can be used to reject tokens that were issued too far away from the current time, 
  684.              *   limiting the amount of time that nonces need to be stored to prevent attacks. The acceptable range is Client specific. 
  685.              **/
  686.             Long old = null;
  687.             try {
  688.                 old = OpenSPCoop2Properties.getInstance().getGestioneTokenIatTimeCheckMilliseconds();
  689.             }catch(Exception e) {
  690.                 throw new TokenException(e.getMessage(),e);
  691.             }
  692.             if(old!=null) {
  693.                 Date oldMax = new Date((DateManager.getTimeMillis() - old.longValue()));
  694.                 if(esitoRecuperoAttributi.getInformazioniAttributi().getIat().before(oldMax)) {
  695.                     esitoRecuperoAttributi.setTokenScaduto();
  696.                     esitoRecuperoAttributi.setDateValide(false);
  697.                     SimpleDateFormat sdf = DateUtils.getDefaultDateTimeFormatter(GestoreToken.DATE_FORMAT);
  698.                     esitoRecuperoAttributi.setDetails("Response attributes expired; iat time '"+sdf.format(esitoRecuperoAttributi.getInformazioniAttributi().getIat())+"' too old");
  699.                 }
  700.             }
  701.             Long future = null;
  702.             try {
  703.                 future = OpenSPCoop2Properties.getInstance().getGestioneTokenIatTimeCheckFutureToleranceMilliseconds();
  704.             }catch(Exception e) {
  705.                 throw new TokenException(e.getMessage(),e);
  706.             }
  707.             if(future!=null) {
  708.                 Date futureMax = new Date((DateManager.getTimeMillis() + future.longValue()));
  709.                 if(esitoRecuperoAttributi.getInformazioniAttributi().getIat().after(futureMax)) {
  710.                     esitoRecuperoAttributi.setTokenInTheFuture();
  711.                     esitoRecuperoAttributi.setDateValide(false);
  712.                     SimpleDateFormat sdf = DateUtils.getDefaultDateTimeFormatter(GestoreToken.DATE_FORMAT);
  713.                     esitoRecuperoAttributi.setDetails("Response attributes valid in the future; iat time '"+sdf.format(esitoRecuperoAttributi.getInformazioniAttributi().getIat())+"' is in the future");
  714.                 }
  715.             }
  716.         }
  717.         
  718.         if(esitoRecuperoAttributi.isValido()) {     
  719.             String audience = dynamicParameters.getResponseAudience();
  720.             if(audience!=null && !"".equals(audience) &&
  721.                 ( esitoRecuperoAttributi.getInformazioniAttributi().getAud()==null || !esitoRecuperoAttributi.getInformazioniAttributi().getAud().contains(audience) ) 
  722.                 ){              
  723.                 esitoRecuperoAttributi.setTokenValidazioneFallita();
  724.                 esitoRecuperoAttributi.setNoCache(!policyAttributeAuthority.isSaveErrorInCache());
  725.                 esitoRecuperoAttributi.setDetails("Invalid audience");  
  726.             }
  727.         }
  728.         
  729.         if(
  730.             esitoRecuperoAttributi.isValido() &&
  731.             (esitoRecuperoAttributi.getInformazioniAttributi().getAttributes()==null || esitoRecuperoAttributi.getInformazioniAttributi().getAttributes().isEmpty())
  732.             ) {
  733.             esitoRecuperoAttributi.setNoCache(!policyAttributeAuthority.isSaveErrorInCache());
  734.             esitoRecuperoAttributi.setDetails("No attributes retrieved");
  735.         }
  736.         
  737.         if(!esitoRecuperoAttributi.isValido()) {
  738.             esitoRecuperoAttributi.setNoCache(!saveErrorInCache);
  739.         }
  740.     }
  741.     
  742.     private static HttpResponse http(Logger log, PolicyAttributeAuthority policyAttributeAuthority,
  743.             IProtocolFactory<?> protocolFactory,
  744.             AttributeAuthorityDynamicParameters dynamicParameters,
  745.             String request,
  746.             IState state, boolean delegata, String idModulo, PortaApplicativa pa, PortaDelegata pd,
  747.             IDSoggetto idDominio, IDServizio idServizio,
  748.             Busta busta, RequestInfo requestInfo) throws Exception {
  749.         
  750.         // *** Raccola Parametri ***
  751.         
  752.         String endpoint = dynamicParameters.getEndpoint();
  753.         HttpRequestMethod httpMethod = policyAttributeAuthority.getRequestHttpMethod();
  754.         
  755.         
  756.         // Nell'endpoint config ci finisce i timeout e la configurazione proxy
  757.         Properties endpointConfig = policyAttributeAuthority.getProperties().get(Costanti.POLICY_ENDPOINT_CONFIG);
  758.         
  759.         boolean https = policyAttributeAuthority.isEndpointHttps();
  760.         boolean httpsClient = false;
  761.         Properties sslConfig = null;
  762.         Properties sslClientConfig = null;
  763.         if(https) {
  764.             sslConfig = policyAttributeAuthority.getProperties().get(Costanti.POLICY_ENDPOINT_SSL_CONFIG);
  765.             httpsClient = policyAttributeAuthority.isHttpsAuthentication();
  766.             if(httpsClient) {
  767.                 sslClientConfig = policyAttributeAuthority.getProperties().get(Costanti.POLICY_ENDPOINT_SSL_CLIENT_CONFIG);
  768.                 TokenUtilities.injectSameKeystoreForHttpsClient(sslConfig, sslClientConfig);
  769.             }
  770.         }
  771.         
  772.         boolean basic = policyAttributeAuthority.isBasicAuthentication();
  773.         String username = null;
  774.         String password = null;
  775.         if(basic) {
  776.             username = dynamicParameters.getBasicUsername();
  777.             password = dynamicParameters.getBasicPassword();
  778.         }
  779.         
  780.         boolean bearer = policyAttributeAuthority.isBearerAuthentication();
  781.         String bearerToken = null;
  782.         if(bearer) {
  783.             bearerToken = dynamicParameters.getBearerToken();
  784.         }
  785.         
  786.         
  787.         
  788.         // *** Definizione Endpoint ***
  789.         
  790.         ConnettoreMsg connettoreMsg = new ConnettoreMsg();
  791.         ConnettoreBaseHTTP connettore = null;
  792.         if(https) {
  793.             connettoreMsg.setTipoConnettore(TipiConnettore.HTTPS.getNome());
  794.             connettore = new ConnettoreHTTPS();
  795.         }
  796.         else {
  797.             connettoreMsg.setTipoConnettore(TipiConnettore.HTTP.getNome());
  798.             connettore = new ConnettoreHTTP();
  799.         }
  800.         connettoreMsg.setIdModulo(idModulo);
  801.         connettoreMsg.setState(state);
  802.         PolicyTimeoutConfig policyConfig = new PolicyTimeoutConfig();
  803.         policyConfig.setAttributeAuthority(policyAttributeAuthority.getName());
  804.         connettoreMsg.setPolicyTimeoutConfig(policyConfig);
  805.         
  806.         ForwardProxy forwardProxy = null;
  807.         ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(state);
  808.         if(configurazionePdDManager.isForwardProxyEnabled(requestInfo)) {
  809.             try {
  810.                 IDGenericProperties policy = new IDGenericProperties();
  811.                 policy.setTipologia(CostantiConfigurazione.GENERIC_PROPERTIES_ATTRIBUTE_AUTHORITY);
  812.                 policy.setNome(policyAttributeAuthority.getName());
  813.                 if(delegata) {
  814.                     forwardProxy = configurazionePdDManager.getForwardProxyConfigFruizione(idDominio, idServizio, policy, requestInfo);
  815.                 }
  816.                 else {
  817.                     forwardProxy = configurazionePdDManager.getForwardProxyConfigErogazione(idDominio, idServizio, policy, requestInfo);
  818.                 }
  819.             }catch(Exception e) {
  820.                 throw new TokenException(GestoreToken.getMessageErroreGovWayProxy(e),e);
  821.             }
  822.         }
  823.         if(forwardProxy!=null && forwardProxy.isEnabled() && forwardProxy.getConfigToken()!=null && forwardProxy.getConfigToken().isAttributeAuthorityEnabled()) {
  824.             connettoreMsg.setForwardProxy(forwardProxy);
  825.         }
  826.         
  827.         connettore.setForceDisable_proxyPassReverse(true);
  828.         connettore.init(dynamicParameters.getPddContext(), protocolFactory);
  829.         connettore.setRegisterSendIntoContext(false);
  830.         
  831.         if(basic){
  832.             InvocazioneCredenziali credenziali = new InvocazioneCredenziali();
  833.             credenziali.setUser(username);
  834.             credenziali.setPassword(password);
  835.             connettoreMsg.setCredenziali(credenziali);
  836.         }
  837.         
  838.         connettoreMsg.setConnectorProperties(new java.util.HashMap<>());
  839.         connettoreMsg.getConnectorProperties().put(CostantiConnettori.CONNETTORE_LOCATION, endpoint);
  840.         OpenSPCoop2Properties properties = OpenSPCoop2Properties.getInstance();
  841.         boolean debug = properties.isGestioneAttributeAuthorityDebug(); 
  842.         if(debug) {
  843.             connettoreMsg.getConnectorProperties().put(CostantiConnettori.CONNETTORE_DEBUG, true+"");
  844.         }
  845.         connettoreMsg.getConnectorProperties().put(CostantiConnettori.CONNETTORE_HTTP_DATA_TRANSFER_MODE, TransferLengthModes.CONTENT_LENGTH.getNome());
  846.         GestoreToken.addProperties(connettoreMsg, endpointConfig);
  847.         if(https) {
  848.             GestoreToken.addProperties(connettoreMsg, sslConfig);
  849.             if(httpsClient) {
  850.                 GestoreToken.addProperties(connettoreMsg, sslClientConfig);
  851.             }
  852.         }
  853.         
  854.         byte[] content = null;
  855.         
  856.         TransportRequestContext transportRequestContext = new TransportRequestContext(log);
  857.         transportRequestContext.setRequestType(httpMethod.name());
  858.         transportRequestContext.setHeaders(new HashMap<>());
  859.         if(bearer) {
  860.             String authorizationHeader = HttpConstants.AUTHORIZATION_PREFIX_BEARER+bearerToken;
  861.             TransportUtils.setHeader(transportRequestContext.getHeaders(),HttpConstants.AUTHORIZATION, authorizationHeader);
  862.         }
  863.         
  864.         
  865.         // *** request *** 
  866.         String contentType = policyAttributeAuthority.getRequestContentType();
  867.         if(contentType!=null && !"".equals(contentType)) {
  868.             transportRequestContext.removeHeader(HttpConstants.CONTENT_TYPE);
  869.             TransportUtils.setHeader(transportRequestContext.getHeaders(),HttpConstants.CONTENT_TYPE, contentType);
  870.         }
  871.         
  872.         String requestPayload = request;
  873.         if(policyAttributeAuthority.isRequestJws()) {
  874.             requestPayload = signAAJwt(policyAttributeAuthority, request, contentType, 
  875.                     dynamicParameters,
  876.                     busta, requestInfo, log);
  877.         }
  878.         if(policyAttributeAuthority.isRequestPositionBearer()) {
  879.             if(transportRequestContext.getHeaders()==null) {
  880.                 transportRequestContext.setHeaders(new HashMap<>());
  881.             }
  882.             String authorizationHeader = HttpConstants.AUTHORIZATION_PREFIX_BEARER+requestPayload;
  883.             TransportUtils.setHeader(transportRequestContext.getHeaders(),HttpConstants.AUTHORIZATION, authorizationHeader);
  884.         }
  885.         else if(policyAttributeAuthority.isRequestPositionHeader()) {
  886.             if(transportRequestContext.getHeaders()==null) {
  887.                 transportRequestContext.setHeaders(new HashMap<>());
  888.             }
  889.             String headerName = policyAttributeAuthority.getRequestPositionHeaderName();
  890.             TransportUtils.setHeader(transportRequestContext.getHeaders(),headerName, requestPayload);
  891.         }
  892.         else if(policyAttributeAuthority.isRequestPositionQuery()) {
  893.             if(transportRequestContext.getParameters()==null) {
  894.                 transportRequestContext.setParameters(new HashMap<>());
  895.             }
  896.             String queryParameterName = policyAttributeAuthority.getRequestPositionQueryParameterName();
  897.             TransportUtils.setParameter(transportRequestContext.getParameters(), queryParameterName, requestPayload);
  898.         }
  899.         else if(policyAttributeAuthority.isRequestPositionPayload()) {
  900.             content = requestPayload.getBytes();
  901.         }
  902.         
  903.             
  904.         OpenSPCoop2MessageParseResult pr = OpenSPCoop2MessageFactory.getDefaultMessageFactory().createMessage(MessageType.BINARY, transportRequestContext, content);
  905.         OpenSPCoop2Message msg = pr.getMessage_throwParseException();
  906.         connettoreMsg.setRequestMessage(msg);
  907.         connettoreMsg.setGenerateErrorWithConnectorPrefix(false);
  908.         connettore.setHttpMethod(msg);
  909.         connettore.setPa(pa);
  910.         connettore.setPd(pd);
  911.         
  912.         ResponseCachingConfigurazione responseCachingConfigurazione = new ResponseCachingConfigurazione();
  913.         responseCachingConfigurazione.setStato(StatoFunzionalita.DISABILITATO);
  914.         String prefixConnettore = "[EndpointAttributeAuthority: "+endpoint+"] ";
  915.         if(endpointConfig.containsKey(CostantiConnettori.CONNETTORE_HTTP_PROXY_HOSTNAME)) {
  916.             String hostProxy = endpointConfig.getProperty(CostantiConnettori.CONNETTORE_HTTP_PROXY_HOSTNAME);
  917.             String portProxy = endpointConfig.getProperty(CostantiConnettori.CONNETTORE_HTTP_PROXY_PORT);
  918.             prefixConnettore = prefixConnettore+GestoreToken.getMessageViaProxy(hostProxy, portProxy);
  919.         }
  920.         boolean send = connettore.send(responseCachingConfigurazione, connettoreMsg);
  921.         if(!send) {
  922.             if(connettore.getEccezioneProcessamento()!=null) {
  923.                 throw new TokenException(prefixConnettore+connettore.getErrore(), connettore.getEccezioneProcessamento());
  924.             }
  925.             else {
  926.                 throw new TokenException(prefixConnettore+connettore.getErrore());
  927.             }
  928.         }
  929.         
  930.         OpenSPCoop2Message msgResponse = connettore.getResponse();
  931.         ByteArrayOutputStream bout = null;
  932.         if(msgResponse!=null) {
  933.             bout = new ByteArrayOutputStream();
  934.             if(msgResponse!=null) {
  935.                 msgResponse.writeTo(bout, true);
  936.             }
  937.             bout.flush();
  938.             bout.close();
  939.         }
  940.         
  941.         HttpResponse httpResponse = new HttpResponse();
  942.         httpResponse.setResultHTTPOperation(connettore.getCodiceTrasporto());
  943.         
  944.         if(connettore.getCodiceTrasporto() >= 200 &&  connettore.getCodiceTrasporto() < 299) {
  945.             String msgSuccess = prefixConnettore+GestoreToken.getMessageConnettoreConnessioneSuccesso(connettore);
  946.             if(bout!=null && bout.size()>0) {
  947.                 log.debug(msgSuccess);
  948.                 httpResponse.setContent(bout.toByteArray());
  949.                 return httpResponse;
  950.             }
  951.             else {
  952.                 throw new TokenException(msgSuccess+GestoreToken.CONNETTORE_RISPOSTA_NON_PERVENUTA);
  953.             }
  954.         }
  955.         else {
  956.             String msgError = prefixConnettore+GestoreToken.getMessageConnettoreConnessioneErrore(connettore);
  957.             if(bout!=null && bout.size()>0) {
  958.                 String e = msgError+": "+bout.toString();
  959.                 log.debug(e);
  960.                 httpResponse.setContent(bout.toByteArray());
  961.                 return httpResponse;
  962.             }
  963.             else {
  964.                 log.error(msgError);
  965.                 throw new TokenException(msgError);
  966.             }
  967.         }
  968.         
  969.         
  970.     }
  971.     
  972.     private static String signAAJwt(PolicyAttributeAuthority policyAttributeAuthority, String payload, String contentType,
  973.             AttributeAuthorityDynamicParameters dynamicParameters,
  974.             Busta busta, RequestInfo requestInfo, Logger log) throws TokenException, SecurityException, UtilsException {
  975.         
  976.         String signAlgo = policyAttributeAuthority.getRequestJwtSignAlgorithm();
  977.         if(signAlgo==null) {
  978.             throw new TokenException("SignAlgorithm undefined");
  979.         }
  980.         
  981.         JWSOptions options = new JWSOptions(JOSESerialization.COMPACT);
  982.         
  983.         String keystoreType = policyAttributeAuthority.getRequestJwtSignKeystoreType();
  984.         if(keystoreType==null) {
  985.             throw new TokenException("JWT Signature keystore type undefined");
  986.         }
  987.         
  988.         String keystoreFile = null;
  989.         String keystoreFilePublicKey = null;
  990.         String keyPairAlgorithm = null;
  991.         if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType)) {
  992.             keystoreFile = policyAttributeAuthority.getRequestJwtSignKeystoreFile();
  993.             if(keystoreFile==null) {
  994.                 throw new TokenException("JWT Signature private key file undefined");
  995.             }
  996.             keystoreFilePublicKey = policyAttributeAuthority.getRequestJwtSignKeystoreFilePublicKey();
  997.             if(keystoreFilePublicKey==null) {
  998.                 throw new TokenException("JWT Signature public key file undefined");
  999.             }
  1000.             keyPairAlgorithm = policyAttributeAuthority.getRequestJwtSignKeystoreFileAlgorithm();
  1001.             if(keyPairAlgorithm==null) {
  1002.                 throw new TokenException("JWT Signature key pair algorithm undefined");
  1003.             }
  1004.         }
  1005.         else {
  1006.             keystoreFile = policyAttributeAuthority.getRequestJwtSignKeystoreFile();
  1007.             if(keystoreFile==null) {
  1008.                 throw new TokenException("JWT Signature keystore file undefined");
  1009.             }
  1010.         }
  1011.         
  1012.         
  1013.         

  1015.         String keystorePassword = policyAttributeAuthority.getRequestJwtSignKeystorePassword();
  1016.         if(keystorePassword==null && 
  1017.                 !SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(keystoreType) && 
  1018.                 !SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType)) {
  1019.             boolean required = true;
  1020.             if(KeystoreType.JKS.isType(keystoreType)) {
  1021.                 required = DBUtils.isKeystoreJksPasswordRequired();
  1022.             }
  1023.             else if(KeystoreType.PKCS12.isType(keystoreType)) {
  1024.                 required = DBUtils.isKeystorePkcs12PasswordRequired();
  1025.             }
  1026.             if(required) {
  1027.                 throw new TokenException("JWT Signature keystore password undefined");
  1028.             }
  1029.         }
  1030.         
  1031.         String keyAlias = policyAttributeAuthority.getRequestJwtSignKeyAlias();
  1032.         if(keyAlias==null && 
  1033.                 !SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType)) {
  1034.             throw new TokenException(GestoreToken.KEY_ALIAS_UNDEFINED);
  1035.         }
  1036.         
  1037.         String keyPassword = policyAttributeAuthority.getRequestJwtSignKeyPassword();
  1038.         if(keyPassword==null && 
  1039.                 !SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType) &&
  1040.                 !SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(keystoreType)) {
  1041.             boolean required = true;
  1042.             if(KeystoreType.JKS.isType(keystoreType)) {
  1043.                 required = DBUtils.isKeystoreJksKeyPasswordRequired();
  1044.             }
  1045.             else if(KeystoreType.PKCS12.isType(keystoreType)) {
  1046.                 required = DBUtils.isKeystorePkcs12KeyPasswordRequired();
  1047.             }
  1048.             if(required) {
  1049.                 throw new TokenException(GestoreToken.KEY_PASSWORD_UNDEFINED);
  1050.             }
  1051.         }
  1052.         
  1053.         String keystoreByokPolicy = policyAttributeAuthority.getRequestJwtSignKeystoreByokPolicy();
  1054.         BYOKRequestParams byokParams = null;
  1055.         if(BYOKProvider.isPolicyDefined(keystoreByokPolicy)) {
  1056.             Map<String, Object> dynamicMap = DynamicMapBuilderUtils.buildDynamicMap(busta, 
  1057.                     requestInfo, dynamicParameters.getPddContext(), log);
  1058.             byokParams = BYOKProvider.getBYOKRequestParamsByUnwrapBYOKPolicy(keystoreByokPolicy, 
  1059.                     dynamicMap );
  1060.         }
  1061.         
  1062.         KeyStore ks = null;
  1063.         KeyPairStore keyPairStore = null;
  1064.         JWKSetStore jwtStore = null;
  1065.         if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreType)) {
  1066.             keyPairStore = GestoreKeystoreCache.getKeyPairStore(requestInfo, keystoreFile, keystoreFilePublicKey, keyPassword, keyPairAlgorithm, byokParams);
  1067.         }
  1068.         else if(SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(keystoreType)) {
  1069.             jwtStore = GestoreKeystoreCache.getJwkSetStore(requestInfo, keystoreFile, byokParams);
  1070.         }
  1071.         else {
  1072.             MerlinKeystore merlinKs = GestoreKeystoreCache.getMerlinKeystore(requestInfo, keystoreFile, keystoreType, keystorePassword, byokParams);
  1073.             if(merlinKs==null) {
  1074.                 throw new TokenException("Accesso al keystore '"+keystoreFile+"' non riuscito");
  1075.             }
  1076.             ks = merlinKs.getKeyStore();
  1077.         }
  1078.         
  1079.         JwtHeaders jwtHeaders = new JwtHeaders();
  1080.         if(policyAttributeAuthority.isRequestJwtSignIncludeKeyIdWithKeyAlias()) {
  1081.             jwtHeaders.setKid(keyAlias);
  1082.         }
  1083.         else if(policyAttributeAuthority.isRequestJwtSignIncludeKeyIdCustom()) {
  1084.             jwtHeaders.setKid(policyAttributeAuthority.getRequestJwtSignIncludeKeyIdCustom());
  1085.         }
  1086.         if(policyAttributeAuthority.isRequestJwtSignIncludeX509Cert()) {
  1087.             jwtHeaders.setAddX5C(true);
  1088.         }
  1089.         String url = policyAttributeAuthority.getRequestJwtSignIncludeX509URL();
  1090.         if(url!=null && !"".equals(url)) {
  1091.             try {
  1092.                 jwtHeaders.setX509Url(new URI(url));
  1093.             }catch(Exception e) {
  1094.                 throw new TokenException(e.getMessage(),e);
  1095.             }
  1096.         }
  1097.         if(policyAttributeAuthority.isRequestJwtSignIncludeX509CertSha1()) {
  1098.             jwtHeaders.setX509IncludeCertSha1(true);
  1099.         }
  1100.         if(policyAttributeAuthority.isRequestJwtSignIncludeX509CertSha256()) {
  1101.             jwtHeaders.setX509IncludeCertSha256(true);
  1102.         }
  1103.         if(policyAttributeAuthority.isRequestJwtSignJoseContentType() &&
  1104.             contentType!=null && !"".equals(contentType)) {
  1105.             jwtHeaders.setContentType(contentType);
  1106.         }
  1107.         String type = policyAttributeAuthority.getRequestJwtSignJoseType();
  1108.         if(type!=null && !"".equals(type) && !Costanti.POLICY_RETRIEVE_TOKEN_JWT_CLAIM_UNDEFINED.equals(type)) { // funzionalita' undefined undocumented
  1109.             jwtHeaders.setType(type);
  1110.         }
  1111.         if(ks!=null) {
  1112.             Certificate cert = ks.getCertificate(keyAlias);
  1113.             if(cert instanceof X509Certificate) {
  1114.                 jwtHeaders.addX509cert((X509Certificate)cert);
  1115.             }
  1116.         }
  1117.         
  1118.         JsonSignature jsonSignature = null;
  1119.         if(keyPairStore!=null || jwtStore!=null) {
  1120.             JsonWebKeys jwk = null;
  1121.             if(keyPairStore!=null) {
  1122.                 jwk = keyPairStore.getJwkSet().getJsonWebKeys();
  1123.                 keyAlias = keyPairStore.getJwkSetKid();
  1124.             }
  1125.             else {
  1126.                 jwk = jwtStore.getJwkSet().getJsonWebKeys();
  1127.             }
  1128.             jsonSignature = new JsonSignature(jwk, false, keyAlias, signAlgo, jwtHeaders, options);
  1129.         }
  1130.         else {
  1131.             jsonSignature = new JsonSignature(ks, false, keyAlias,  keyPassword, signAlgo, jwtHeaders, options);
  1132.         }
  1133.         
  1134.         return jsonSignature.sign(payload);
  1135.         
  1136.     }
  1137.     
  1138. }
Created with JaCoCo 0.8.8.202204050719