CertificateUtils.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.utils.certificate;

  23. import java.security.PrivateKey;
  24. import java.util.ArrayList;
  25. import java.util.Collections;
  26. import java.util.Enumeration;
  27. import java.util.HashMap;
  28. import java.util.List;
  29. import java.util.Map;

  31. import javax.security.auth.x500.X500Principal;

  33. import org.apache.xml.security.utils.RFC2253Parser;
  34. import org.openspcoop2.utils.Utilities;
  35. import org.openspcoop2.utils.UtilsException;
  36. import org.openspcoop2.utils.UtilsMultiException;
  37. import org.openspcoop2.utils.io.Base64Utilities;
  38. import org.openspcoop2.utils.io.HexBinaryUtilities;
  39. import org.openspcoop2.utils.resources.Charset;
  40. import org.slf4j.Logger;
  41. import org.springframework.web.util.UriUtils;

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

  54.     public static void printCertificate(StringBuilder bf,List<java.security.cert.X509Certificate> certs){
  55.         printCertificate(bf, certs, false);
  56.     }
  57.     public static void printCertificate(StringBuilder bf,List<java.security.cert.X509Certificate> certs, boolean addPrefix){
  58.         if(!certs.isEmpty()) {
  59.             java.security.cert.X509Certificate[] certsArray = certs.toArray(new java.security.cert.X509Certificate[1]);
  60.             printCertificate(bf, certsArray, addPrefix);
  61.         }
  62.         else {
  63.             bf.append("X509Certificates: "+0+"\n");
  64.         }
  65.     }
  66.     
  67.     public static void printCertificate(StringBuilder bf,java.security.cert.X509Certificate[] certs){
  68.         printCertificate(bf, certs, false);
  69.     }
  70.     public static void printCertificate(StringBuilder bf,java.security.cert.X509Certificate[] certs, boolean addPrefix){
  71.         bf.append("X509Certificates: "+certs.length+"\n");
  72.         for (int i = 0; i < certs.length; i++) {
  73.             java.security.cert.X509Certificate cert = certs[i];
  74.             printCertificate(bf, cert, i+"", addPrefix);
  75.         }
  76.     }
  77.     
  78.     public static void printCertificate(StringBuilder bf,java.security.cert.X509Certificate cert, String name){
  79.         printCertificate(bf, cert, name, false);
  80.     }
  81.     public static void printCertificate(StringBuilder bf,java.security.cert.X509Certificate cert, String name, boolean addPrefix){
  82.         String prefix = "";
  83.         if(addPrefix) {
  84.             prefix = "Cert["+name+"].";
  85.         }
  86.         bf.append("#### X509Certificate["+name+"]\n");
  87.         bf.append("\t"+prefix+"toString()="+cert.toString()+"\n");
  88.         bf.append("\t"+prefix+"getType()="+cert.getType()+"\n");
  89.         bf.append("\t"+prefix+"getVersion()="+cert.getVersion()+"\n");
  90.         
  91.         if(cert.getIssuerDN()!=null){
  92.             bf.append("\t"+prefix+"cert.getIssuerDN().toString()="+cert.getIssuerDN().toString()+"\n");
  93.             bf.append("\t"+prefix+"cert.getIssuerDN().getName()="+cert.getIssuerDN().getName()+"\n");
  94.         }
  95.         else{
  96.             bf.append("\t"+prefix+"cert.getIssuerDN() is null"+"\n");
  97.         }
  98.         
  99.         if(cert.getIssuerX500Principal()!=null){
  100.             bf.append("\t"+prefix+"getIssuerX500Principal().toString()="+cert.getIssuerX500Principal().toString()+"\n");
  101.             bf.append("\t"+prefix+"getIssuerX500Principal().getName()="+cert.getIssuerX500Principal().getName()+"\n");
  102.             bf.append("\t"+prefix+"getIssuerX500Principal().getName(X500Principal.CANONICAL)="+cert.getIssuerX500Principal().getName(X500Principal.CANONICAL)+"\n");
  103.             bf.append("\t"+prefix+"getIssuerX500Principal().getName(X500Principal.RFC1779)="+cert.getIssuerX500Principal().getName(X500Principal.RFC1779)+"\n");
  104.             bf.append("\t"+prefix+"getIssuerX500Principal().getName(X500Principal.RFC2253)="+cert.getIssuerX500Principal().getName(X500Principal.RFC2253)+"\n");
  105.             /** Map<String,String> oidMapCanonical = new HashMap<>();
  106.                 bf.append("\t"+prefix+"getIssuerX500Principal().getName(X500Principal.CANONICAL,oidMapCanonical)="+
  107.                         cert.getIssuerX500Principal().getName(X500Principal.CANONICAL,oidMapCanonical));
  108.                 if(oidMapCanonical!=null && oidMapCanonical.size()>0){
  109.                     Iterator<String> it = oidMapCanonical.keySet().iterator();
  110.                     while (it.hasNext()) {
  111.                         String key = (String) it.next();
  112.                         String value = oidMapCanonical.get(key);
  113.                         bf.append("\t"+prefix+"getIssuerX500Principal() ["+key+"]=["+value+"]"+"\n");
  114.                     }
  115.                 }*/
  116.         }
  117.         else{
  118.             bf.append("\t"+prefix+"cert.getIssuerX500Principal() is null"+"\n");
  119.         }
  120.         
  121.         if(cert.getSubjectDN()!=null){
  122.             bf.append("\t"+prefix+"getSubjectDN().toString()="+cert.getSubjectDN().toString()+"\n");
  123.             bf.append("\t"+prefix+"getSubjectDN().getName()="+cert.getSubjectDN().getName()+"\n");
  124.         }
  125.         else{
  126.             bf.append("\t"+prefix+"cert.getSubjectDN() is null"+"\n");
  127.         }
  128.         
  129.         bf.append("\t"+prefix+"getSerialNumber()="+cert.getSerialNumber()+"\n");
  130.         bf.append("\t"+prefix+"getNotAfter()="+cert.getNotAfter()+"\n");
  131.         bf.append("\t"+prefix+"getNotBefore()="+cert.getNotBefore()+"\n");
  132.         
  133.         if(cert.getSubjectX500Principal()!=null){
  134.             bf.append("\t"+prefix+"getSubjectX500Principal().toString()="+cert.getSubjectX500Principal().toString()+"\n");
  135.             bf.append("\t"+prefix+"getSubjectX500Principal().getName()="+cert.getSubjectX500Principal().getName()+"\n");
  136.             bf.append("\t"+prefix+"getSubjectX500Principal().getName(X500Principal.CANONICAL)="+cert.getSubjectX500Principal().getName(X500Principal.CANONICAL)+"\n");
  137.             bf.append("\t"+prefix+"getSubjectX500Principal().getName(X500Principal.RFC1779)="+cert.getSubjectX500Principal().getName(X500Principal.RFC1779)+"\n");
  138.             bf.append("\t"+prefix+"getSubjectX500Principal().getName(X500Principal.RFC2253)="+cert.getSubjectX500Principal().getName(X500Principal.RFC2253)+"\n");
  139.             /** Map<String,String> oidMapCanonical = new HashMap<>();
  140.                 bf.append("\t"+prefix+"getSubjectX500Principal().getName(X500Principal.CANONICAL,oidMapCanonical)="+
  141.                         cert.getSubjectX500Principal().getName(X500Principal.CANONICAL,oidMapCanonical));
  142.                 if(oidMapCanonical!=null && oidMapCanonical.size()>0){
  143.                     Iterator<String> it = oidMapCanonical.keySet().iterator();
  144.                     while (it.hasNext()) {
  145.                         String key = (String) it.next();
  146.                         String value = oidMapCanonical.get(key);
  147.                         bf.append("\t"+prefix+"getSubjectX500Principal() ["+key+"]=["+value+"]"+"\n");
  148.                     }
  149.                 }*/
  150.         }
  151.         else{
  152.             bf.append("\t"+prefix+"cert.getSubjectX500Principal() is null"+"\n");
  153.         }
  154.     }
  155.     
  156.     
  157.     
  158.     
  159.     
  160.     
  161.     /* UTILITY SSL */
  162.     
  163.     private static final boolean TRIM_VALUE_BEFORE_SAVE_DB = true;
  164.     
  165.     private static void debug(Logger log, String msg) {
  166.         if(log!=null) {
  167.             log.debug(msg);
  168.         }
  169.     }
  170.     private static String getAnalisiTypePrefixString(String principal, PrincipalType type) {
  171.         return "("+principal+") Analisi "+type+" ";
  172.     }
  173.     
  174.     public static boolean sslVerify(String principalPresenteNellaConfigurazione, String principalArrivatoConnessioneSSL, PrincipalType type, Logger log) throws UtilsException{

  176.         if(log!=null) {
  177.             debug(log, "SSL VERIFY CONF["+principalPresenteNellaConfigurazione+"] SSL["+principalArrivatoConnessioneSSL+"]");
  178.         }
  179.         /** System.out.println("SSL VERIFY CONF["+principalPresenteNellaConfigurazione+"] SSL["+principalArrivatoConnessioneSSL+"]"); */

  181.         // Costruzione key=value
  182.         Map<String, List<String>> hashPrincipalArrivatoConnessioneSSL = CertificateUtils.getPrincipalIntoMap(principalArrivatoConnessioneSSL, type);
  183.         Map<String, List<String>> hashPrincipalPresenteNellaConfigurazione = CertificateUtils.getPrincipalIntoMap(principalPresenteNellaConfigurazione, type);

  185.         if(!sslVerifyCheckSize(principalPresenteNellaConfigurazione, principalArrivatoConnessioneSSL, type, 
  186.                 hashPrincipalArrivatoConnessioneSSL, hashPrincipalPresenteNellaConfigurazione, log)) {
  187.             return false;
  188.         }

  190.         for (Map.Entry<String,List<String>> entry : hashPrincipalArrivatoConnessioneSSL.entrySet()) {

  192.             String key = entry.getKey();
  193.             
  194.             if(!hashPrincipalPresenteNellaConfigurazione.containsKey(key)){
  195.                 /** System.out.println("KEY ["+key+"] non presente"); */
  196.                 if(log!=null) {
  197.                     List<String> lKeys = new ArrayList<>();
  198.                     lKeys.addAll(hashPrincipalPresenteNellaConfigurazione.keySet());
  199.                     debug(log, "sslVerify key["+key+"] non trovata in "+type+" "+"Configurazione["+principalPresenteNellaConfigurazione+"]"+", key riscontrate: "+
  200.                             lKeys);
  201.                 }
  202.                 return false;
  203.             }

  205.             // Prendo valori
  206.             List<String> connessioneSSLValueList = hashPrincipalArrivatoConnessioneSSL.get(key);
  207.             List<String> configurazioneInternaValueList = hashPrincipalPresenteNellaConfigurazione.get(key);
  208.             if(connessioneSSLValueList.size() != configurazioneInternaValueList.size()){
  209.                 /** System.out.println("LUNGHEZZA DIVERSA KEY ["+key+"]"); */
  210.                 if(log!=null) {
  211.                     debug(log, "sslVerify "+type+" key["+key+"] trovata in Configurazione["+principalPresenteNellaConfigurazione+"]("+configurazioneInternaValueList.size()+
  212.                         ") SSL["+principalArrivatoConnessioneSSL+"]("+connessioneSSLValueList.size()+"): lunghezza differente");
  213.                 }
  214.                 return false;
  215.             }
  216.             
  217.             // Ordino Valori
  218.             Collections.sort(connessioneSSLValueList);
  219.             Collections.sort(configurazioneInternaValueList);
  220.             
  221.             // confronto valori
  222.             if(!sslVerifyCheckValues(key, type, connessioneSSLValueList, configurazioneInternaValueList, log)) {
  223.                 return false;
  224.             }
  225.             
  226.         }

  228.         /** System.out.println("SSL RETURN TRUE"); */
  229.         return true;

  231.     }
  232.     private static boolean sslVerifyCheckSize(String principalPresenteNellaConfigurazione, String principalArrivatoConnessioneSSL, PrincipalType type, 
  233.             Map<String, List<String>> hashPrincipalArrivatoConnessioneSSL, Map<String, List<String>> hashPrincipalPresenteNellaConfigurazione, Logger log) {
  234.         if(hashPrincipalArrivatoConnessioneSSL.size() != hashPrincipalPresenteNellaConfigurazione.size()){
  235.             /** System.out.println("LUNGHEZZA DIVERSA"); */
  236.             if(log!=null) {
  237.                 debug(log, "sslVerify "+type+" "+"Configurazione["+principalPresenteNellaConfigurazione+"]"+"("+hashPrincipalPresenteNellaConfigurazione.size()+
  238.                     ") SSL["+principalArrivatoConnessioneSSL+"]("+hashPrincipalArrivatoConnessioneSSL.size()+"): lunghezza differente");
  239.             }
  240.             return false;
  241.         }
  242.         return true;
  243.     }
  244.     private static boolean sslVerifyCheckValues(String key, PrincipalType type, List<String> connessioneSSLValueList, List<String> configurazioneInternaValueList, Logger log) {
  245.         for (int i = 0; i < connessioneSSLValueList.size(); i++) {
  246.             String connessioneSSLValue = connessioneSSLValueList.get(i);
  247.             String configurazioneInternaValue = configurazioneInternaValueList.get(i);
  248.             
  249.             // Normalizzo caratteri escape
  250.             while(connessioneSSLValue.contains("\\/")){
  251.                 connessioneSSLValue = connessioneSSLValue.replace("\\/", "/");
  252.             }
  253.             while(connessioneSSLValue.contains("\\,")){
  254.                 connessioneSSLValue = connessioneSSLValue.replace("\\,", ",");
  255.             }
  256.             while(configurazioneInternaValue.contains("\\/")){
  257.                 configurazioneInternaValue = configurazioneInternaValue.replace("\\/", "/");
  258.             }
  259.             while(configurazioneInternaValue.contains("\\,")){
  260.                 configurazioneInternaValue = configurazioneInternaValue.replace("\\,", ",");
  261.             }
  262.             
  263.             if(!connessioneSSLValue.equals(configurazioneInternaValue)){
  264.                 if(log!=null) {
  265.                     debug(log, "sslVerify key["+key+"] "+type+" Configurazione["+configurazioneInternaValue+"] SSL["+connessioneSSLValue+"] not match");
  266.                 }
  267.                 /** System.out.println("VALUE SSL["+connessioneSSLValue+"]=CONF["+configurazioneInternaValue+"] non match"); */
  268.                 return false;
  269.             }
  270.         }
  271.         return true;
  272.     }


  275.     public static String formatPrincipal(String principal, PrincipalType type) throws UtilsException{

  277.         /** System.out.println("PRIMA ["+principal+"]"); */
  278.         
  279.         // Autenticazione SSL deve essere LIKE
  280.         Map<String, List<String>> hashPrincipal = CertificateUtils.getPrincipalIntoMap(principal, type);
  281.         StringBuilder bf = new StringBuilder();
  282.         bf.append("/");
  283.         for (Map.Entry<String,List<String>> entry : hashPrincipal.entrySet()) {
  284.             
  285.             String key = entry.getKey();
  286.             
  287.             List<String> listValues = hashPrincipal.get(key);
  288.             for (String value : listValues) {
  289.                 bf.append(CertificateUtils.formatKeyPrincipal(key));
  290.                 bf.append("=");
  291.                 bf.append(CertificateUtils.formatValuePrincipal(value));
  292.                 bf.append("/");
  293.             }
  294.             
  295.         }
  296.         /** System.out.println("DOPO ["+bf.toString()+"]"); */
  297.         return bf.toString();
  298.     }
  299.     
  300.     public static Map<String, String> formatPrincipalToMap(String principal, PrincipalType type) throws UtilsException{
  301.         Map<String, String> returnMap = new HashMap<>();
  302.         Map<String, List<String>> hashPrincipal = CertificateUtils.getPrincipalIntoMap(principal, type);
  303.         for (Map.Entry<String,List<String>> entry : hashPrincipal.entrySet()) {
  304.             
  305.             String key = entry.getKey();
  306.             
  307.             List<String> listValues = hashPrincipal.get(key);
  308.             for (String value : listValues) {
  309.                 String keyFormat = CertificateUtils.formatKeyPrincipal(key);
  310.                 String valueFormat = CertificateUtils.formatValuePrincipal(value);
  311.                 returnMap.put(keyFormat, valueFormat);
  312.             }
  313.             
  314.         }
  315.         return returnMap;
  316.     }

  318.     public static void validaPrincipal(String principalParam, PrincipalType type) throws UtilsException{
  319.         
  320.         /** System.out.println("PRIMA VALIDAZIONE ["+principalParam+"]"); */
  321.         
  322.         String principal = principalParam;
  323.         UtilsException normalizedException = null;
  324.         try{
  325.             String tmp = normalizePrincipal(principalParam);
  326.             principal = tmp;
  327.         }catch(UtilsException e){
  328.             /** System.out.println("ERRORE: "+e.getMessage());
  329.             // non voglio rilanciare l'eccezione, verra' segnalata l'eccezione puntuale.
  330.             // Se cosi' non fosse solo in fondo viene sollevata l'eccezione. */
  331.             normalizedException = e;
  332.         }
  333.         
  334.         /** System.out.println("DOPOP VALIDAZIONE ["+principal+"]"); */
  335.         
  336.         boolean commaFound = contains(principal, ",");
  337.         boolean slashFound = contains(principal, "/");
  338.         if(commaFound && slashFound){
  339.             throw new UtilsException("("+principal+") Non possono coesistere i separatore \",\" e \"/\", solo uno dei due tipi deve essere utilizzato come delimitatore (usare eventualmente come carattere di escape '\\')");
  340.         }
  341.         if(!commaFound && !slashFound && !principal.contains("=")){
  342.             throw new UtilsException("("+principal+") "+type+" non valido, nemmeno una coppia nome=valore trovata");
  343.         }
  344.         String [] valoriPrincipal = CertificateUtils.getValoriPrincipal(principal, type);
  345.         validaPrincipal(valoriPrincipal, principal, type);
  346.         
  347.         if(normalizedException!=null){
  348.             throw normalizedException;
  349.         }
  350.     }
  351.     private static void validaPrincipal(String [] valoriPrincipal, String principal, PrincipalType type) throws UtilsException {
  352.         boolean campoObbligatorioCN = false;
  353.         boolean campoObbligatorioOU = false;
  354.         boolean campoObbligatorioO = false;
  355.         boolean campoObbligatorioL = false;
  356.         boolean campoObbligatorioST = false;
  357.         boolean campoObbligatorioC = false;
  358.         boolean campoObbligatorioE = false;
  359.         for(int i=0; i<valoriPrincipal.length; i++){
  360.             
  361.             String [] keyValue = getKeyValuePairEngine(valoriPrincipal[i], principal, type);

  363.             if(keyValue[0].trim().contains(" ")){
  364.                 throw new UtilsException(getAnalisiTypePrefixString(principal, type)+"fallita: il campo ["+valoriPrincipal[i]+"] contiene spazi nella chiave identificativa ["+keyValue[0].trim()+"]");
  365.             }
  366.             
  367.             if(CertificateUtils.formatKeyPrincipal(keyValue[0]).equalsIgnoreCase("CN")){
  368.                 campoObbligatorioCN = true;
  369.             }
  370.             else if(CertificateUtils.formatKeyPrincipal(keyValue[0]).equalsIgnoreCase("OU")){
  371.                 campoObbligatorioOU = true;
  372.             }
  373.             else if(CertificateUtils.formatKeyPrincipal(keyValue[0]).equalsIgnoreCase("O")){
  374.                 campoObbligatorioO = true;
  375.             }
  376.             else if(CertificateUtils.formatKeyPrincipal(keyValue[0]).equalsIgnoreCase("L")){
  377.                 campoObbligatorioL = true;
  378.             }
  379.             else if(CertificateUtils.formatKeyPrincipal(keyValue[0]).equalsIgnoreCase("ST")){
  380.                 campoObbligatorioST = true;
  381.             }
  382.             else if(CertificateUtils.formatKeyPrincipal(keyValue[0]).equalsIgnoreCase("C")){
  383.                 campoObbligatorioC = true;
  384.             }
  385.             else if(CertificateUtils.formatKeyPrincipal(keyValue[0]).equalsIgnoreCase("E")){
  386.                 campoObbligatorioE = true;
  387.             }
  388.         }
  389.         if(!campoObbligatorioCN && !campoObbligatorioOU && !campoObbligatorioO && !campoObbligatorioL && !campoObbligatorioST && !campoObbligatorioC && !campoObbligatorioE){
  390.             throw new UtilsException("("+principal+") Almeno un attributo di certificato tra 'CN', 'OU', 'O', 'L', 'ST', 'C' e 'E' deve essere valorizzato.");
  391.         }
  392.     }

  394.     
  395.     public static String normalizePrincipal(String principalParam) throws UtilsException{
  396.         
  397.         /*
  398.          *  The principal extract from class represents an X.500 Principal. 
  399.          *  X500Principals are represented by distinguished names such as "CN=Duke, OU=JavaSoft, O=Sun Microsystems, C=US".
  400.          *  This class can be instantiated by using a string representation of the distinguished name, or by using the ASN.1 DER encoded byte representation 
  401.          *  of the distinguished name. 
  402.          *  The current specification for the string representation of a distinguished name is defined in RFC 2253: 
  403.          *  Lightweight Directory Access Protocol (v3): UTF-8 String Representation of Distinguished Names. 
  404.          *  This class, however, accepts string formats from both RFC 2253 and RFC 1779: A String Representation of Distinguished Names, 
  405.          *  and also recognizes attribute type keywords whose OIDs (Object Identifiers) are defined in RFC 3280:
  406.          *  Internet X.509 Public Key Infrastructure Certificate and CRL Profile. 
  407.          */
  408.         
  409.         try{
  410.             // Normalizza da un eventuale formato human readable o da un formato RFC 1779 nel formato RFC 2253 gestito poi nel seguito del codice.
  411.             // Alcuni esempi dove il carattere '/' viene usato internamente come valore del CN
  412.             // Esempio di formato "human readable": /C=IT/ST=Italiy/OU=PROVA di Bari, di Como/CN=SPC/SOGGETTO
  413.             // Esempio di formato "RFC 1779": CN=SPC/SOGGETTO, OU="PROVA di Bari, di Como", ST=Italiy, C=IT
  414.             // Esempio di formato "RFC 2253": CN=SPC/SOGGETTO,OU=PROVA di Bari\, di Como,ST=Italiy,C=IT
  415.             return RFC2253Parser.normalize(principalParam);
  416.             /**String principal = RFC2253Parser.normalize(principalParam);
  417.             System.out.println(" ORIGINALE ["+principalParam+"]  NORMALIZZATO ["+principal+"]");
  418.             return principal;*/
  419.         }catch(Exception e){
  420.             throw new UtilsException("("+principalParam+") Normalizzazione RFC2253 non riuscita: "+e.getMessage(),e);
  421.         }
  422.     }

  424.     public static String [] getValoriPrincipal(String principalParam, PrincipalType type) throws UtilsException{
  425.         try{
  426.             /** System.out.println("PRINCIPAL getValoriPrincipal["+principalParam+"]"); */
  427.             String principal = normalizePrincipal(principalParam);
  428.             /** System.out.println("PRINCIPAL dopo normalize getValoriPrincipal["+principal+"]"); */
  429.             
  430.             return getValoriPrincipalEngine(principal, type);
  431.             
  432.         }catch(Exception e){
  433.             
  434.             /** System.out.println("PRINCIPAL getValoriPrincipal["+principalParam+"] errore: "+e.getMessage()); */
  435.             
  436.             try{
  437.             
  438.                 javax.naming.ldap.LdapName prova = new javax.naming.ldap.LdapName(principalParam);
  439.                 Enumeration<String> ens = prova.getAll();
  440.                 List<String> values = new ArrayList<>();
  441.                 while (ens.hasMoreElements()) {
  442.                     String name = ens.nextElement();
  443.                     values.add(name);
  444.                 }
  445.                 
  446.                 if(!values.isEmpty()){
  447.                     return values.toArray(new String[1]);
  448.                 }
  449.                 else{
  450.                     throw new UtilsException("Coppie nome/valore non trovate");
  451.                 }
  452.                 
  453.             }catch(Exception e2Level){
  454.                 /**e2Level.printStackTrace(System.out); */
  455.                 throw new UtilsException("("+principalParam+") javax.naming.ldap.LdapName reader failed: "+e2Level.getMessage()+". \nFirst method error: "+e.getMessage(),e);
  456.             }
  457.                 
  458.         }
  459.     }
  460.         
  461.     private static String [] getValoriPrincipalEngine(String principal, PrincipalType type) throws UtilsException{
  462.             
  463.         String [] valori;
  464.         boolean commaFound = contains(principal, ",");
  465.         boolean slashFound = contains(principal, "/");
  466.         /**System.out.println("PRINCIPAL _getValoriPrincipal commaFound["+commaFound+"] slashFound["+slashFound+"]"); */
  467.         if(commaFound){
  468.             if(principal.startsWith(",")){
  469.                 principal = principal.substring(1);
  470.             }
  471.             if(principal.endsWith(",")){
  472.                 principal = principal.substring(0,principal.length()-1);
  473.             }
  474.             /**System.out.println("PRINCIPAL _getValoriPrincipal preSplit , ["+principal+"] ..");*/
  475.             valori = Utilities.split(principal, ',');
  476.         }else{
  477.             valori = getValoriPrincipalEngine(principal, type, slashFound);
  478.         }
  479.         if(valori==null || valori.length<1){
  480.             throw new UtilsException(getAnalisiTypePrefixString(principal, type)+"interno alla configurazione di OpenSPCoop non riuscita: null??");
  481.         }
  482.         
  483.         // validazione
  484.         for(int i=0; i<valori.length; i++){
  485.             getKeyValuePairEngine(valori[i], principal, type);
  486.         }
  487.                 
  488.         return valori;
  489.     }
  490.     private static String [] getValoriPrincipalEngine(String principal, PrincipalType type, boolean slashFound) throws UtilsException {
  491.         /**System.out.println("PRINCIPAL _getValoriPrincipal comma not found ["+principal+"] .."); */
  492.         String [] valori = null;
  493.         if(!slashFound){
  494.             /** System.out.println("PRINCIPAL _getValoriPrincipal slash not found ["+principal+"] .."); */
  495.             int indexOf = principal.indexOf("=");
  496.             if(indexOf<=0){
  497.                 throw new UtilsException("("+principal+") Separatore validi per il "+type+" interno alla configurazione di OpenSPCoop non trovati:  \",\" o \"/\" e carattere \"=\" non presente");
  498.             }
  499.             if(principal.indexOf("=",indexOf+1)>=0){
  500.                 throw new UtilsException("("+principal+") Separatore validi per il "+type+" interno alla configurazione di OpenSPCoop non trovati:  \",\" o \"/\"");
  501.             }
  502.             valori =  new String[1];
  503.             valori[0] = principal;
  504.         }else{
  505.             valori = getValoriSlashPrincipalEngine(principal);
  506.         }
  507.         return valori;
  508.     }
  509.     private static String [] getValoriSlashPrincipalEngine(String principal) throws UtilsException {
  510.         if(principal.startsWith("/")){
  511.             principal = principal.substring(1);
  512.         }
  513.         if(principal.endsWith("/")){
  514.             principal = principal.substring(0,principal.length()-1);
  515.         }
  516.         /**System.out.println("PRINCIPAL _getValoriPrincipal preSplit / ["+principal+"] .."); */
  517.         String [] tmpValori = Utilities.split(principal, '/');
  518.         
  519.         // Bug Fix OP-670 certificato formato come:
  520.         // C=IT/ST= /O=Esempio di Agenzia/OU=Servizi Informatici/CN=Ministero dell'Interno/prova/23234234554/DEMO
  521.         List<String> normalize = new ArrayList<>();
  522.         StringBuilder bf = new StringBuilder();
  523.         for (String tmp : tmpValori) {
  524.             if(tmp.contains("=")) {
  525.                 if(bf.length()>0) {
  526.                     normalize.add(bf.toString());
  527.                     bf.delete(0, bf.length());
  528.                 }
  529.                 bf.append(tmp);
  530.             }
  531.             else {
  532.                 bf.append("/").append(tmp);
  533.             }
  534.         }
  535.         if(bf.length()>0) {
  536.             normalize.add(bf.toString());
  537.             bf.delete(0, bf.length());
  538.         }
  539.         return normalize.toArray(new String[1]);
  540.     }
  541.     
  542.     public static Map<String, List<String>> getPrincipalIntoMap(String principal, PrincipalType type) throws UtilsException{
  543.         Map<String, List<String>> hashPrincipal = new HashMap<>();
  544.         String [] valoriPrincipal = CertificateUtils.getValoriPrincipal(principal, type);
  545.         for(int i=0; i<valoriPrincipal.length; i++){
  546.             
  547.             // override eccezione in caso '=' non rpesente
  548.             if(!valoriPrincipal[i].contains("=")){
  549.                 String fallita = "fallita"+": ["+valoriPrincipal[i]+"] ";
  550.                 throw new UtilsException(getAnalisiTypePrefixString(principal, type)+fallita+"non separata dal carattere \"=\"");
  551.             }
  552.             String [] keyValue = getKeyValuePairEngine(valoriPrincipal[i], principal, type);
  553.             
  554.             /**System.out.println("CONF INTERNA ["+Utilities.formatKeyPrincipal(keyValue[0])+"] ["+Utilities.formatValuePrincipal(keyValue[1])+"]");*/
  555.             String formatKey = CertificateUtils.formatKeyPrincipal(keyValue[0]);
  556.             String formatValue = CertificateUtils.formatValuePrincipal(keyValue[1]);
  557.             List<String> listValue = null;
  558.             if(hashPrincipal.containsKey(formatKey)) {
  559.                 listValue = hashPrincipal.get(formatKey);
  560.             }
  561.             else {
  562.                 listValue = new ArrayList<>();
  563.                 hashPrincipal.put(formatKey, listValue);
  564.             }
  565.             listValue.add(formatValue);
  566.         }
  567.         return hashPrincipal;
  568.     }

  570.     public static String formatKeyPrincipal(String keyPrincipal){
  571.         return keyPrincipal.trim().toLowerCase();
  572.     }
  573.     public static String formatValuePrincipal(String valuePrincipal){
  574.         // siccome uso il carattere '/' come separatore, un eventuale '/' deve essere escaped.
  575.         StringBuilder bf = new StringBuilder();
  576.         for (int i = 0; i < valuePrincipal.length(); i++) {
  577.             if(valuePrincipal.charAt(i)=='/'){
  578.                 // escape
  579.                 if(i==0){
  580.                     bf.append('\\');
  581.                 }
  582.                 else{
  583.                     // verifico se non ho gia' effettuato l'escape
  584.                     if(valuePrincipal.charAt((i-1))!='\\'){
  585.                         bf.append('\\');
  586.                     }
  587.                 }
  588.             }
  589.             bf.append(valuePrincipal.charAt(i));
  590.         }
  591.         String value = bf.toString();
  592.         if(TRIM_VALUE_BEFORE_SAVE_DB) {
  593.             value = value.trim();
  594.         }
  595.         return value;
  596.     }

  598.     private static String[] getKeyValuePairEngine(String keyValue, String principal, PrincipalType type) throws UtilsException {
  599.         
  600.         if(!keyValue.contains("=")){
  601.             throw new UtilsException(getAnalisiTypePrefixString(principal, type)+"fallita: ["+keyValue+"] non separata dal carattere \"=\". Verificare che non esistano coppie che possiedono valori che contengono il carattere separatore (usare eventualmente come carattere di escape '\\')");
  602.         }
  603.         
  604.         // Bug Fix OP-664
  605.         // Per non bruciare gli spazi presenti nei valori della chiave che sono ammessi. Ad esempio e' capitato un "C=IT,ST= ,CN=XXESEMPIOXX"
  606.         /**String [] keyValue = keyValue.trim().split("=");*/
  607.         String [] keyValueReturn = keyValue.split("="); // lo spazio รจ ammesso nel valore.      
  608.         if(keyValueReturn.length<2){
  609.             if(TRIM_VALUE_BEFORE_SAVE_DB && keyValueReturn.length==1) {
  610.                 // Serve per i valori inseriti che poi vengono comunque normalizzati con il trim. Se il valore era ' ' viene normalizzato a ''
  611.                 // una volta riletto poi si ottiene l'errore.
  612.                 // Che ci sia l'uguale e' garantito dai controlli sopra. In pratica keyValue.endsWith("=")
  613.                 String key = keyValueReturn[0];
  614.                 keyValueReturn = new String[2];
  615.                 keyValueReturn[0] = key;
  616.                 keyValueReturn[1] = "";
  617.             }
  618.             else {
  619.                 throw new UtilsException(getAnalisiTypePrefixString(principal, type)+"fallita: ["+keyValue+"] non contiene un valore? Verificare che non esistano coppie che possiedono valori che contengono il carattere separatore (usare eventualmente come carattere di escape '\\')");
  620.             }
  621.         }
  622.         
  623.         // Lo spazio e' ammesso nel valore, ma non nella chiave
  624.         keyValueReturn[0] = keyValueReturn[0].trim();
  625.         /**System.out.println("KEY["+keyValueReturn[0]+"]=VALUE["+keyValueReturn[1]+"]");*/
  626.         
  627.         // Questo controllo non deve essere fatto poiche' il valore puo' contenere il '='.
  628. /**     if(keyValue.length!=2){
  629. //          throw new UtilsException(getAnalisiTypePrefixString(principal, type)+"fallita: ["+keyValue+"] contiene piu' di un carattere \"=\"");
  630. //      }*/
  631.         if(keyValueReturn.length==2) {
  632.             return keyValueReturn;
  633.         }
  634.         else {
  635.             String[] keyValueReturnNormalized = new String[2];
  636.             keyValueReturnNormalized[0] = keyValueReturn[0];
  637.             keyValueReturnNormalized[1] = extractValueFromKeyPairEngine(keyValue);
  638.             return keyValueReturnNormalized;
  639.         }
  640.         
  641.     }
  642.     private static String extractValueFromKeyPairEngine(String keyValue) throws UtilsException {
  643.         // Questo metodo server poiche' il valore puo' contenere il '=' ed il carattere ' ' anche all'inizio o alla fine.
  644.         // Quindi uno split con il carattere '=' non puo' essere usato.
  645.         // Deve quindi essere estratto dopo il primo uguale
  646.         int indexOf = keyValue.indexOf("=");
  647.         if(indexOf<=0) {
  648.             throw new UtilsException("Carattere '=' non presente in ["+keyValue+"]");
  649.         }
  650.         return keyValue.substring(indexOf+1);
  651.         /**String valoreEstratto = keyValue.substring(indexOf+1);
  652.         System.out.println("VALORE ESTRATTO ["+valoreEstratto+"]");
  653.         return valoreEstratto;*/
  654.     }
  655.     
  656.     
  657.     private static boolean contains(String value,String separator){
  658.         int indexOf = value.indexOf(separator);
  659.         boolean found = false;
  660.         if(indexOf==0){
  661.             found = true;
  662.         }
  663.         else{
  664.             boolean itera = true;
  665.             while(indexOf>0 && itera){
  666.                 char precedente = value.charAt(indexOf-1);
  667.                 if(precedente == '\\'){
  668.                     if(indexOf+1>value.length()){
  669.                         itera=false;
  670.                     }
  671.                     else{
  672.                         indexOf = value.indexOf(separator,indexOf+1);
  673.                     }
  674.                 }
  675.                 else{
  676.                     found = true;
  677.                     itera=false;
  678.                 }
  679.             }
  680.         }
  681.         return found;
  682.     }
  683.     
  684.     public static Certificate readCertificate(CertificateDecodeConfig config, String certificateParam) throws UtilsException {
  685.         return readCertificateEngine(config, certificateParam, Charset.UTF_8.getValue());
  686.     }
  687.     public static Certificate readCertificate(CertificateDecodeConfig config, String certificateParam, String charset) throws UtilsException {
  688.         return readCertificateEngine(config, certificateParam, charset);
  689.     }
  690.     
  691.     private static Certificate readCertificateEngine(CertificateDecodeConfig config, String certificateParam, String charset) throws UtilsException {
  692.         if(config.isUrlDecodeOrBase64Decode() || config.isUrlDecodeOrBase64DecodeOrHexDecode()) {
  693.             
  694.             Throwable tUrlDecode = null;
  695.             try {
  696.                 config.setUrlDecode(true);
  697.                 config.setBase64Decode(false);
  698.                 config.setHexDecode(false);
  699.                 return readCertificateEngineByConfig(config, certificateParam, charset);
  700.             }catch(Exception t) {
  701.                 tUrlDecode = t;
  702.             }
  703.             
  704.             Throwable tBase64Decode = null;
  705.             try {
  706.                 config.setUrlDecode(false);
  707.                 config.setBase64Decode(true);
  708.                 config.setHexDecode(false);
  709.                 return readCertificateEngineByConfig(config, certificateParam, charset);
  710.             }catch(Exception t) {
  711.                 tBase64Decode = t;
  712.             }
  713.             
  714.             Throwable tHexDecode = null;
  715.             if(config.isUrlDecodeOrBase64DecodeOrHexDecode()) {
  716.                 try {
  717.                     config.setUrlDecode(false);
  718.                     config.setBase64Decode(false);
  719.                     config.setHexDecode(true);
  720.                     return readCertificateEngineByConfig(config, certificateParam, charset);
  721.                 }catch(Exception t) {
  722.                     tHexDecode = t;
  723.                 }
  724.             }
  725.             
  726.             UtilsMultiException uMulti = config.isUrlDecodeOrBase64DecodeOrHexDecode() ?
  727.                 new UtilsMultiException("Decodifica non riuscita", tUrlDecode, tBase64Decode, tHexDecode)   
  728.                     :
  729.                 new UtilsMultiException("Decodifica non riuscita", tUrlDecode, tBase64Decode);
  730.             throw new UtilsException(uMulti.getMessage(),uMulti);
  731.         }
  732.         else {
  733.             return readCertificateEngineByConfig(config, certificateParam, charset);
  734.         }
  735.     }
  736.     private static Certificate readCertificateEngineByConfig(CertificateDecodeConfig config, String certificateParam, String charset) throws UtilsException {
  737.         
  738.         if(certificateParam==null || "".equals(certificateParam)){
  739.             throw new UtilsException("Certificate non fornito");
  740.         }
  741.         
  742.         try {
  743.         
  744.             String certificate = certificateParam;
  745.             
  746.             if(config.isUrlDecode()) {
  747.                 certificate = UriUtils.decode(certificate, charset);
  748.             }
  749.             
  750.             boolean forceEnrichPEMBeginEnd = false;
  751.             if(config.isReplace()) {
  752.                 StringBuilder sbNewCertificate = new StringBuilder();
  753.                 forceEnrichPEMBeginEnd = replaceCharacters(config, certificate, sbNewCertificate);
  754.                 certificate = sbNewCertificate.toString();
  755.             }
  756.             
  757.             if(config.isEnrichPEMBeginEnd() || forceEnrichPEMBeginEnd) {
  758.                 certificate = addPEMDeclaration(certificate, forceEnrichPEMBeginEnd);
  759.             }
  760.             
  761.             byte [] certBytes = null;
  762.             if(config.isBase64Decode()) {
  763.                 certBytes = Base64Utilities.decode(certificate);
  764.             }
  765.             else if(config.isHexDecode()) {
  766.                 certBytes = HexBinaryUtilities.decode(certificate);
  767.             }
  768.             else {
  769.                 certBytes = certificate.getBytes(charset);
  770.             }
  771.             
  772.             // Per adesso l'utility di load gestisce solo il tipo DER. La decodifica in base64 รจ quindi essenziale, a meno che non sia un DER.
  773.             
  774.             return ArchiveLoader.load(certBytes);
  775.             
  776.         }catch(Exception e) {
  777.             throw new UtilsException(e.getMessage(), e);
  778.         }
  779.         
  780.     } 
  781.     
  782.     private static boolean replaceCharacters(CertificateDecodeConfig config, String certificate, StringBuilder sbNewCertificate) {
  783.         boolean forceEnrichPEMBeginEnd = false;
  784.         // per evitare di sovrascrivere 'BEGIN' e 'END'
  785.         if(certificate.startsWith(PEMReader.X509_BEGIN) && certificate.length()>PEMReader.X509_BEGIN.length()) {
  786.             certificate = certificate.substring(PEMReader.X509_BEGIN.length());
  787.             forceEnrichPEMBeginEnd = true;
  788.         }
  789.         if(certificate.endsWith(PEMReader.X509_END) && certificate.length()>PEMReader.X509_END.length()) {
  790.             certificate = certificate.substring(0, certificate.length()-PEMReader.X509_END.length());
  791.         }
  792.         
  793.         int index = 0; // per evitare bug di cicli infiniti
  794.         while(certificate.contains(config.getReplaceSource()) && index<10000) {
  795.             certificate = certificate.replace(config.getReplaceSource(), config.getReplaceDest());
  796.             index++;
  797.         }
  798.         sbNewCertificate.append(certificate);
  799.         return forceEnrichPEMBeginEnd;
  800.     }
  801.     
  802.     private static String addPEMDeclaration(String certificate, boolean forceEnrichPEMBeginEnd) {
  803.         if(!certificate.startsWith(PEMReader.X509_BEGIN)) {
  804.             certificate = PEMReader.X509_BEGIN+ (forceEnrichPEMBeginEnd?"":"\n")+ certificate;
  805.         }
  806.         if(!certificate.endsWith(PEMReader.X509_END)) {
  807.             certificate = certificate+ (forceEnrichPEMBeginEnd?"":"\n") +PEMReader.X509_END;
  808.         }
  809.         return certificate;
  810.     }
  811.     
  812.     public static String toPEM(java.security.cert.X509Certificate cert) throws UtilsException {
  813.         try {
  814.             java.io.StringWriter sw = new java.io.StringWriter();
  815.             try (org.bouncycastle.openssl.jcajce.JcaPEMWriter pw = new org.bouncycastle.openssl.jcajce.JcaPEMWriter(sw)) {
  816.                 pw.writeObject(cert);
  817.             }
  818.             sw.flush();
  819.             sw.close();
  820.             return sw.toString();
  821.         }catch(Exception e) {
  822.             throw new UtilsException(e.getMessage(), e);
  823.         }
  824.     }
  825.     public static String toPEM(PrivateKey privateKey) throws UtilsException {
  826.         try {
  827.             java.io.StringWriter sw = new java.io.StringWriter();
  828.             try (org.bouncycastle.openssl.jcajce.JcaPEMWriter pw = new org.bouncycastle.openssl.jcajce.JcaPEMWriter(sw)) {
  829.                 pw.writeObject(privateKey);
  830.             }
  831.             sw.flush();
  832.             sw.close();
  833.             return sw.toString();
  834.         }catch(Exception e) {
  835.             throw new UtilsException(e.getMessage(), e);
  836.         }
  837.     }
  838. }
Created with JaCoCo 0.8.8.202204050719