KeyStore.java

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


  22. package org.openspcoop2.utils.certificate;

  24. import java.io.File;
  25. import java.security.Key;
  26. import java.security.PrivateKey;
  27. import java.security.PublicKey;
  28. import java.security.cert.Certificate;
  29. import java.security.cert.X509Certificate;
  30. import java.util.Enumeration;
  31. import java.util.HashMap;
  32. import java.util.Map;

  34. import javax.crypto.SecretKey;
  35. import javax.security.auth.x500.X500Principal;

  37. import org.apache.cxf.common.util.Base64UrlUtility;
  38. import org.apache.cxf.rt.security.crypto.MessageDigestUtils;
  39. import org.openspcoop2.utils.UtilsException;
  40. import org.openspcoop2.utils.resources.FileSystemUtilities;

  42. /** 
  43.  * Keystore
  44.  *
  45.  * @author Poli Andrea (apoli@link.it)
  46.  * @author $Author$
  47.  * @version $Rev$, $Date$
  48.  */
  49. public class KeyStore {
  50.     
  51.     private java.security.KeyStore keystoreArchive;
  52.     private boolean keystoreHsm;
  53.     
  54.     public KeyStore(String keystorePath,String passwordKeystore) throws UtilsException{
  55.         this(keystorePath,KeystoreType.JKS.getNome(),passwordKeystore);
  56.     }
  57.     public KeyStore(String keystorePath,String tipoKeystore, String passwordKeystore) throws UtilsException{
  58.         this(new File(keystorePath),tipoKeystore,passwordKeystore);
  59.     }
  60.     public KeyStore(File keystorePath,String passwordKeystore) throws UtilsException{
  61.         this(keystorePath,KeystoreType.JKS.getNome(),passwordKeystore);
  62.     }
  63.     public KeyStore(File keystorePath,String tipoKeystore, String passwordKeystore) throws UtilsException{
  64.         
  65.         if(!keystorePath.exists()){
  66.             throw new UtilsException("Keystore ["+keystorePath+"] not exists");
  67.         }
  68.         if(!keystorePath.canRead()){
  69.             throw new UtilsException("Keystore ["+keystorePath+"] cannot read");
  70.         }
  71.         
  72.         byte [] keystore = null;
  73.         try {
  74.             keystore = FileSystemUtilities.readBytesFromFile(keystorePath);
  75.         }catch(Exception e){
  76.             throw new UtilsException(e.getMessage(),e);
  77.         }
  78.         
  79.         this.keystoreArchive = KeystoreUtils.readKeystore(keystore, tipoKeystore, passwordKeystore);
  80.     }
  81.     
  82.     public KeyStore(byte[] keystore,String passwordKeystore) throws UtilsException{
  83.         this(keystore,KeystoreType.JKS.getNome(),passwordKeystore);
  84.     }
  85.     public KeyStore(byte[] keystore,String tipoKeystore, String passwordKeystore) throws UtilsException{
  86.         
  87.         if(keystore==null){
  88.             throw new UtilsException("Keystore undefined");
  89.         }
  90.         
  91.         this.keystoreArchive = KeystoreUtils.readKeystore(keystore, tipoKeystore, passwordKeystore);
  92.         
  93.     }
  94.     
  95.     
  96.     public KeyStore(java.security.KeyStore keystore) {
  97.         this(keystore, false);
  98.     }
  99.     public KeyStore(java.security.KeyStore keystore, boolean keystoreHsm) {
  100.         this.keystoreArchive = keystore;
  101.         this.keystoreHsm = keystoreHsm;
  102.     }
  103.     
  104.     private Map<String, Key> keys = new HashMap<>(); // effettuo il cache delle chiavi essendo costoso accederci tutte le volte
  105.     private synchronized void initKey(String alias, String password) throws UtilsException {
  106.         if(!this.keys.containsKey(alias)) {
  107.             try{
  108.                 /** System.out.println("******** AGGIUNGO CHIAVE '"+alias+"' IN CACHE!!!!!!!!"); */
  109.                 Key key = null;
  110.                 if(password!=null) {
  111.                     key = this.keystoreArchive.getKey(alias, password.toCharArray());
  112.                 }
  113.                 else {
  114.                     key = this.keystoreArchive.getKey(alias, "".toCharArray());
  115.                 }
  116.                 if(key==null) {
  117.                     throw new UtilsException("Not found");
  118.                 }
  119.                 this.keys.put(alias, key);
  120.             }catch(Exception e){
  121.                 throw new UtilsException(e.getMessage(),e);
  122.             }
  123.         }
  124.     }
  125.     
  126.     public PrivateKey getPrivateKey(String alias,String passwordPrivateKey) throws UtilsException{
  127.         try{
  128.             if(!this.keys.containsKey(alias)) {
  129.                 initKey(alias, passwordPrivateKey);
  130.             }
  131. /**         else {
  132. //              System.out.println("GET KEY '"+alias+"' FROM CACHE");
  133. //          } */
  134.             return (PrivateKey) this.keys.get(alias);
  135.         }catch(Exception e){
  136.             throw new UtilsException(e.getMessage(),e);
  137.         }   
  138.     }
  139.     public SecretKey getSecretKey(String alias,String passwordPrivateKey) throws UtilsException{
  140.         try{
  141.             if(!this.keys.containsKey(alias)) {
  142.                 initKey(alias, passwordPrivateKey);
  143.             }
  144.             return (SecretKey) this.keys.get(alias);
  145.         }catch(Exception e){
  146.             throw new UtilsException(e.getMessage(),e);
  147.         }   
  148.     }

  150.     public Certificate getCertificate() throws UtilsException{
  151.         try{
  152.             Enumeration<String> aliases = this.keystoreArchive.aliases();
  153.             Certificate cer = null;
  154.             while (aliases.hasMoreElements()) {
  155.                 String alias = aliases.nextElement();
  156.                 if(cer!=null){
  157.                     throw new UtilsException("More than one certificate, use alias");
  158.                 }
  159.                 cer = this.keystoreArchive.getCertificate(alias);
  160.             }
  161.             return cer;
  162.         }catch(Exception e){
  163.             throw new UtilsException(e.getMessage(),e);
  164.         }   
  165.     }
  166.     public Certificate getCertificate(String alias) throws UtilsException{
  167.         try{
  168.             return this.keystoreArchive.getCertificate(alias);
  169.         }catch(Exception e){
  170.             throw new UtilsException(e.getMessage(),e);
  171.         }   
  172.     }
  173.     public Certificate[] getCertificateChain(String alias) throws UtilsException{
  174.         try{
  175.             return this.keystoreArchive.getCertificateChain(alias);
  176.         }catch(Exception e){
  177.             throw new UtilsException(e.getMessage(),e);
  178.         }   
  179.     }
  180.     
  181.     public Certificate getCertificateByDigestMD5UrlEncoded(String digest) throws UtilsException{
  182.         return getCertificateByDigestUrlEncoded(digest, MessageDigestUtils.ALGO_MD5);
  183.     }
  184.     public Certificate getCertificateByDigestSHA1UrlEncoded(String digest) throws UtilsException{
  185.         return getCertificateByDigestUrlEncoded(digest, MessageDigestUtils.ALGO_SHA_1);
  186.     }
  187.     public Certificate getCertificateByDigestSHA256UrlEncoded(String digest) throws UtilsException{
  188.         return getCertificateByDigestUrlEncoded(digest, MessageDigestUtils.ALGO_SHA_256);
  189.     }
  190.     public Certificate getCertificateByDigestUrlEncoded(String digest, String digestAlgo) throws UtilsException{
  191.         try{
  192.             Enumeration<String> aliases = this.keystoreArchive.aliases();
  193.             while (aliases.hasMoreElements()) {
  194.                 String alias = aliases.nextElement();
  195.                 Certificate cer = this.keystoreArchive.getCertificate(alias);
  196.                 String digestCer = this.buildDigestUrlEncoded(cer, digestAlgo);
  197.                 if(digestCer.equals(digest)) {
  198.                     return cer;
  199.                 }
  200.             }
  201.             return null;
  202.         }catch(Exception e){
  203.             throw new UtilsException(e.getMessage(),e);
  204.         }   
  205.     }
  206.     
  207.     public Certificate getCertificateBySubject(X500Principal principal) throws UtilsException{
  208.         try{
  209.             if(principal==null) {
  210.                 return null;
  211.             }
  212.             Enumeration<String> aliases = this.keystoreArchive.aliases();
  213.             while (aliases.hasMoreElements()) {
  214.                 String alias = aliases.nextElement();
  215.                 Certificate cer = this.keystoreArchive.getCertificate(alias);
  216.                 if(cer instanceof X509Certificate) {
  217.                     X509Certificate x509 = (X509Certificate) cer;
  218.                     X500Principal subject = x509.getSubjectX500Principal();
  219.                     if(principal.equals(subject)) {
  220.                         return cer;
  221.                     }
  222.                 }
  223.             }
  224.             return null;
  225.         }catch(Exception e){
  226.             throw new UtilsException(e.getMessage(),e);
  227.         }   
  228.     }
  229.     public boolean existsCertificateBySubject(X500Principal principal) throws UtilsException{
  230.         try{
  231.             return this.getCertificateBySubject(principal)!=null;
  232.         }catch(Exception e){
  233.             throw new UtilsException(e.getMessage(),e);
  234.         }   
  235.     }
  236.     
  237.     public Certificate getCertificateByPublicKey(PublicKey publicKey) throws UtilsException{
  238.         try{
  239.             if(publicKey==null) {
  240.                 return null;
  241.             }
  242.             Enumeration<String> aliases = this.keystoreArchive.aliases();
  243.             while (aliases.hasMoreElements()) {
  244.                 String alias = aliases.nextElement();
  245.                 Certificate cer = this.keystoreArchive.getCertificate(alias);
  246.                 PublicKey pk = cer.getPublicKey();
  247.                 if(pk!=null && pk.equals(publicKey)) {
  248.                     return cer;
  249.                 }
  250.             }
  251.             return null;
  252.         }catch(Exception e){
  253.             throw new UtilsException(e.getMessage(),e);
  254.         }   
  255.     }
  256.     public boolean existsCertificateByPublicKey(PublicKey publicKey) throws UtilsException{
  257.         try{
  258.             return this.getCertificateByPublicKey(publicKey)!=null;
  259.         }catch(Exception e){
  260.             throw new UtilsException(e.getMessage(),e);
  261.         }   
  262.     }
  263.     
  264.     public String getDigestMD5UrlEncoded(String alias) throws UtilsException{
  265.         return this.getDigestUrlEncoded(alias, MessageDigestUtils.ALGO_MD5);
  266.     }
  267.     public String getDigestSHA1UrlEncoded(String alias) throws UtilsException{
  268.         return this.getDigestUrlEncoded(alias, MessageDigestUtils.ALGO_SHA_1);
  269.     }
  270.     public String getDigestSHA256UrlEncoded(String alias) throws UtilsException{
  271.         return this.getDigestUrlEncoded(alias, MessageDigestUtils.ALGO_SHA_256);
  272.     }
  273.     public String getDigestUrlEncoded(String alias, String digestAlgo) throws UtilsException{
  274.         try{
  275.             Certificate cer = getCertificate(alias);
  276.             if(cer==null) {
  277.                 throw new UtilsException("Certificate '"+alias+"' not exists");
  278.             }
  279.             return this.buildDigestUrlEncoded(cer, digestAlgo);
  280.         }catch(Exception e){
  281.             throw new UtilsException(e.getMessage(),e);
  282.         }   
  283.     }
  284.     private String buildDigestUrlEncoded(Certificate cer, String digestAlgo) throws UtilsException{
  285.         try{
  286.             byte[] digestB = MessageDigestUtils.createDigest(cer.getEncoded(), digestAlgo);
  287.             return Base64UrlUtility.encode(digestB);
  288.         }catch(Exception e){
  289.             throw new UtilsException(e.getMessage(),e);
  290.         }
  291.     }
  292.     
  293.     public boolean existsAlias(String alias) throws UtilsException{
  294.         try{
  295.             return this.keystoreArchive.containsAlias(alias);
  296.         }catch(Exception e){
  297.             throw new UtilsException(e.getMessage(),e);
  298.         }   
  299.     }
  300.     public Enumeration<String> aliases() throws UtilsException{
  301.         try{
  302.             return this.keystoreArchive.aliases();
  303.         }catch(Exception e){
  304.             throw new UtilsException(e.getMessage(),e);
  305.         }
  306.     }
  307.     public PublicKey getPublicKey() throws UtilsException{
  308.         return this.getCertificate().getPublicKey();
  309.     }
  310.     public PublicKey getPublicKey(String alias) throws UtilsException{
  311.         return this.getCertificate(alias).getPublicKey();
  312.     }
  313.     
  314.     public java.security.KeyStore getKeystore() {
  315.         return this.keystoreArchive;
  316.     }
  317.     public boolean isKeystoreHsm() {
  318.         return this.keystoreHsm;
  319.     }
  320.     public String getKeystoreType() {
  321.         if(this.keystoreArchive==null) {
  322.             return null;
  323.         }
  324.         return this.keystoreArchive.getType();
  325.     }
  326.     public java.security.Provider getKeystoreProvider() {
  327.         return this.keystoreArchive.getProvider();
  328.     }
  329.     
  330.     public void putCertificate(String alias, Certificate cert, boolean overwriteIfExists) throws UtilsException {
  331.         if(this.existsAlias(alias)) {
  332.             if(overwriteIfExists) {
  333.                 try {
  334.                     this.keystoreArchive.deleteEntry(alias);
  335.                 }catch(Exception t) {
  336.                     throw new UtilsException(t.getMessage(),t);
  337.                 }
  338.             }
  339.             else {
  340.                 return;
  341.             }
  342.         }
  343.         try {
  344.             this.keystoreArchive.setCertificateEntry(alias, cert);
  345.         }catch(Exception t) {
  346.             throw new UtilsException(t.getMessage(),t);
  347.         }
  348.     }
  349.     public void putAllCertificate(KeyStore keystore, boolean overwriteIfExists) throws UtilsException {
  350.         if(keystore!=null) {
  351.             Enumeration<String> aliases = keystore.aliases();
  352.             if(aliases!=null) {
  353.                 while (aliases.hasMoreElements()) {
  354.                     String alias = aliases.nextElement();
  355.                     Certificate cert = keystore.getCertificate(alias);
  356.                     putCertificate(alias, cert, overwriteIfExists);
  357.                 }
  358.             }
  359.         }
  360.     }
  361.     
  362. }
Created with JaCoCo 0.8.8.202204050719