KeyUtils.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.  */
  20. package org.openspcoop2.utils.certificate;

  22. import java.io.ByteArrayInputStream;
  23. import java.io.InputStreamReader;
  24. import java.security.KeyFactory;
  25. import java.security.KeyPair;
  26. import java.security.PrivateKey;
  27. import java.security.PublicKey;
  28. import java.security.spec.PKCS8EncodedKeySpec;
  29. import java.security.spec.X509EncodedKeySpec;

  31. import org.apache.commons.lang.StringUtils;
  32. import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;
  33. import org.bouncycastle.openssl.PEMDecryptorProvider;
  34. import org.bouncycastle.openssl.PEMEncryptedKeyPair;
  35. import org.bouncycastle.openssl.PEMKeyPair;
  36. import org.bouncycastle.openssl.PEMParser;
  37. import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter;
  38. import org.bouncycastle.openssl.jcajce.JceOpenSSLPKCS8DecryptorProviderBuilder;
  39. import org.bouncycastle.openssl.jcajce.JcePEMDecryptorProviderBuilder;
  40. import org.bouncycastle.operator.InputDecryptorProvider;
  41. import org.bouncycastle.pkcs.PKCS8EncryptedPrivateKeyInfo;
  42. import org.bouncycastle.util.io.pem.PemReader;
  43. import org.openspcoop2.utils.UtilsException;

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

  54.     public static final String ALGO_RSA = "RSA";
  55.     public static final String ALGO_DSA = "DSA";
  56.     public static final String ALGO_DH = "DH"; // Diffie-Hellman
  57.     public static final String ALGO_EC = "EC"; // Elliptic Curve Digital Signature Algorithm o ECDH (Elliptic Curve Diffie-Hellman).

  59.     
  60.     public static KeyUtils getInstance() throws UtilsException {
  61.         return new KeyUtils();
  62.     }
  63.     public static KeyUtils getInstance(String algo) throws UtilsException {
  64.         return new KeyUtils(algo);
  65.     }
  66.     
  67.     private KeyFactory kf;
  68.     
  69.     public KeyUtils() throws UtilsException {
  70.         this(ALGO_RSA);
  71.     }
  72.     public KeyUtils(String algo) throws UtilsException {
  73.         try {
  74.             this.kf = KeyFactory.getInstance(algo);
  75.         }catch(Exception e) {
  76.             throw new UtilsException(e.getMessage(),e);
  77.         }
  78.     }
  79.     
  80.     // ** PUBLIC KEY **/
  81.     
  82.     public PublicKey readPublicKeyPEMFormat(byte[] publicKey) throws UtilsException {
  83.         
  84.         PEMReader pemArchive = new PEMReader(publicKey);
  85.         if(pemArchive.getPublicKey()!=null) {
  86.             publicKey = pemArchive.getPublicKey().getBytes();
  87.         }
  88.         
  89.         try {
  90.             try (ByteArrayInputStream bin = new ByteArrayInputStream(publicKey);
  91.                     InputStreamReader ir = new InputStreamReader(bin);
  92.                     PemReader pemReader = new PemReader(ir);){
  93.                 byte [] encoded = pemReader.readPemObject().getContent();
  94.                 X509EncodedKeySpec specPub = new X509EncodedKeySpec(encoded);
  95.                 return this.kf.generatePublic(specPub);
  96.             } 
  97.         }catch(Exception e) {
  98.             throw new UtilsException(e.getMessage(),e);
  99.         }
  100.     }
  101.     public PublicKey readPublicKeyDERFormat(byte[] publicKey) throws UtilsException {
  102.         try {
  103.             X509EncodedKeySpec specPub = new X509EncodedKeySpec(publicKey);
  104.             return this.kf.generatePublic(specPub);
  105.         }catch(Exception e) {
  106.             throw new UtilsException(e.getMessage(),e);
  107.         }
  108.     }
  109.     public PublicKey readCertificate(byte[] publicKey) throws UtilsException {
  110.         
  111.         PEMReader pemArchive = new PEMReader(publicKey);
  112.         if(pemArchive.getCertificates()!=null && !pemArchive.getCertificates().isEmpty()) {
  113.             String cert = pemArchive.getCertificates().get(0); // prendo il primo
  114.             if(cert!=null && StringUtils.isNotEmpty(cert)) {
  115.                 publicKey = cert.getBytes();
  116.             }
  117.         }
  118.         
  119.         return ArchiveLoader.load(publicKey).getCertificate().getCertificate().getPublicKey();
  120.     }
  121.     
  122.     public PublicKey getPublicKey(byte[] publicKey) throws UtilsException {
  123.         
  124.         PEMReader pemArchive = new PEMReader(publicKey);
  125.         
  126.         if(pemArchive.getPublicKey()!=null) {
  127.             return this.readPublicKeyPEMFormat(pemArchive.getPublicKey().getBytes());
  128.         }
  129.         else if(pemArchive.getCertificates()!=null && !pemArchive.getCertificates().isEmpty()) {
  130.             String cert = pemArchive.getCertificates().get(0); // prendo il primo
  131.             if(cert!=null && StringUtils.isNotEmpty(cert)) {
  132.                 return this.readCertificate(cert.getBytes());
  133.             }
  134.         }
  135.         
  136.         try {
  137.             return readPublicKeyDERFormat(publicKey);
  138.         }catch(Exception e) {
  139.             // provo X509
  140.             try {
  141.                 return readCertificate(publicKey);
  142.             }catch(Exception ignore) {
  143.                 // rilancio eccezione precedente
  144.                 throw new UtilsException(e.getMessage(),e);
  145.             }
  146.         }
  147.         
  148.     }
  149.     
  150.     
  151.     // ** PRIVATE KEY **/
  152.     
  153.     public PrivateKey readPKCS1PrivateKeyPEMFormat(byte[] privateKey) throws UtilsException {
  154.         
  155.         PEMReader pemArchive = new PEMReader(privateKey,true,false,false);
  156.         if(pemArchive.getPrivateKey()!=null) {
  157.             privateKey = pemArchive.getPrivateKey().getBytes();
  158.         }
  159.         
  160.         // Legge nel formato PEM PKCS1 e lo porta in PKCS8
  161.         
  162.         try {
  163.             try (ByteArrayInputStream bin = new ByteArrayInputStream(privateKey);
  164.                     InputStreamReader ir = new InputStreamReader(bin);){
  165.                 PEMParser pemParser = new PEMParser(ir);
  166.                 JcaPEMKeyConverter converter = new JcaPEMKeyConverter().setProvider(org.bouncycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
  167.                 Object object = pemParser.readObject();
  168.                 KeyPair kp = converter.getKeyPair((PEMKeyPair) object);
  169.                 return kp.getPrivate(); 
  170.             }
  171.         }catch(Exception e) {
  172.             throw new UtilsException(e.getMessage(),e);
  173.         }
  174.     }
  175.     
  176.     public PrivateKey readPKCS8PrivateKeyPEMFormat(byte[] privateKey) throws UtilsException {
  177.         
  178.         PEMReader pemArchive = new PEMReader(privateKey,false,true,false);
  179.         if(pemArchive.getPrivateKey()!=null) {
  180.             privateKey = pemArchive.getPrivateKey().getBytes();
  181.         }
  182.         
  183.         try {
  184.             try (ByteArrayInputStream bin = new ByteArrayInputStream(privateKey);
  185.                     InputStreamReader ir = new InputStreamReader(bin);
  186.                     PemReader pemReader = new PemReader(ir);){
  187.                 byte [] encoded = pemReader.readPemObject().getContent();
  188.                 PKCS8EncodedKeySpec specPriv = new PKCS8EncodedKeySpec(encoded);
  189.                 return this.kf.generatePrivate(specPriv);
  190.             } 
  191.         }catch(Exception e) {
  192.             throw new UtilsException(e.getMessage(),e);
  193.         }
  194.     }
  195.     
  196.     public PrivateKey readPKCS8PrivateKeyDERFormat(byte[] privateKey) throws UtilsException {
  197.         try {
  198.             PKCS8EncodedKeySpec specPriv = new PKCS8EncodedKeySpec(privateKey);
  199.             return this.kf.generatePrivate(specPriv);
  200.         }catch(Exception e) {
  201.             throw new UtilsException(e.getMessage(),e);
  202.         }
  203.     }
  204.     
  205.     public PrivateKey getPrivateKey(byte[] privateKey) throws UtilsException {
  206.         
  207.         PEMReader pemArchive = new PEMReader(privateKey);
  208.         if(pemArchive.getPrivateKey()!=null) {
  209.             privateKey = pemArchive.getPrivateKey().getBytes();
  210.             
  211.             if(pemArchive.isPkcs1()) {
  212.                 return this.readPKCS1PrivateKeyPEMFormat(privateKey);   
  213.             }
  214.             else if(pemArchive.isPkcs8()) {
  215.                 return this.readPKCS8PrivateKeyPEMFormat(privateKey);
  216.             }
  217.         }
  218.         
  219.         return readPKCS8PrivateKeyDERFormat(privateKey);
  220.     }
  221.     
  222.     
  223.     // ** PRIVATE KEY ENCRYPTED **/
  224.     
  225.     public PrivateKey readPKCS1EncryptedPrivateKeyPEMFormat(byte[] privateKey, String password) throws UtilsException{
  226.         
  227.         PEMReader pemArchive = new PEMReader(privateKey,true,false,false);
  228.         if(pemArchive.getPrivateKey()!=null) {
  229.             privateKey = pemArchive.getPrivateKey().getBytes();
  230.         }
  231.         
  232.         // Legge nel formato PEM PKCS1 e lo porta in PKCS8
  233.         
  234.         try {
  235.             try (ByteArrayInputStream bin = new ByteArrayInputStream(privateKey);
  236.                     InputStreamReader ir = new InputStreamReader(bin);){
  237.                 PEMParser pemParser = new PEMParser(ir);
  238.                 JcaPEMKeyConverter converter = new JcaPEMKeyConverter().setProvider(org.bouncycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
  239.                 Object object = pemParser.readObject();
  240.                 PEMEncryptedKeyPair pair = (PEMEncryptedKeyPair) object;
  241.                 JcePEMDecryptorProviderBuilder jce = new JcePEMDecryptorProviderBuilder().setProvider(org.bouncycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
  242.                 PEMDecryptorProvider decProv = jce.build(password.toCharArray());
  243.                 KeyPair kp = converter.getKeyPair(pair.decryptKeyPair(decProv));
  244.                 return kp.getPrivate(); 
  245.             }
  246.         }catch(Exception e) {
  247.             throw new UtilsException(e.getMessage(),e);
  248.         }

  250.     }
  251.         
  252.     public PrivateKey readPKCS8EncryptedPrivateKeyPEMFormat(byte[] privateKey, String password) throws UtilsException{
  253.             
  254.         PEMReader pemArchive = new PEMReader(privateKey,false,false,true);
  255.         if(pemArchive.getPrivateKey()!=null) {
  256.             privateKey = pemArchive.getPrivateKey().getBytes();
  257.         }
  258.         
  259.         PKCS8EncryptedPrivateKeyInfo pair = null;
  260.         try {
  261.             try (ByteArrayInputStream bin = new ByteArrayInputStream(privateKey);
  262.                     InputStreamReader ir = new InputStreamReader(bin);){
  263.                 PEMParser parser = new PEMParser(ir);
  264.                 pair = (PKCS8EncryptedPrivateKeyInfo)parser.readObject();
  265.             }
  266.         }catch(Exception e) {
  267.             throw new UtilsException(e.getMessage(),e);
  268.         }
  269.         return readPKCS8EncryptedPrivateKey(pair, password);

  271.     }
  272.     
  273.     public PrivateKey readPKCS8EncryptedPrivateKeyDERFormat(byte[] privateKey, String password) throws UtilsException{
  274.         PKCS8EncryptedPrivateKeyInfo pair = null;
  275.         try {
  276.             pair = new PKCS8EncryptedPrivateKeyInfo(privateKey);
  277.         }catch(Exception e) {
  278.             throw new UtilsException(e.getMessage(),e);
  279.         }
  280.         return readPKCS8EncryptedPrivateKey(pair, password);
  281.     }
  282.     
  283.     private PrivateKey readPKCS8EncryptedPrivateKey(PKCS8EncryptedPrivateKeyInfo pair, String password) throws UtilsException{
  284.         try {
  285.             JceOpenSSLPKCS8DecryptorProviderBuilder jce = new JceOpenSSLPKCS8DecryptorProviderBuilder().setProvider(org.bouncycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
  286.             InputDecryptorProvider decProv = jce.build(password.toCharArray());
  287.             PrivateKeyInfo keyInfo = pair.decryptPrivateKeyInfo(decProv);
  288.             JcaPEMKeyConverter converter = new JcaPEMKeyConverter().setProvider(org.bouncycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME);
  289.             return converter.getPrivateKey(keyInfo);
  290.         }catch(Exception e) {
  291.             throw new UtilsException(e.getMessage(),e);
  292.         }
  293.     }
  294.     
  295.     public PrivateKey getPrivateKey(byte[] privateKey, String password) throws UtilsException {
  296.         
  297.         PEMReader pemArchive = new PEMReader(privateKey);
  298.         if(pemArchive.getPrivateKey()!=null) {
  299.             privateKey = pemArchive.getPrivateKey().getBytes();
  300.             
  301.             if(pemArchive.isPkcs8encrypted()) {
  302.                 return this.readPKCS8EncryptedPrivateKeyPEMFormat(privateKey, password);
  303.             }
  304.             else if(pemArchive.isPkcs1()) {
  305.                 try {
  306.                     return this.readPKCS1EncryptedPrivateKeyPEMFormat(privateKey, password);
  307.                 }catch(Exception e) {
  308.                     // provo senza password
  309.                     try {
  310.                         return this.readPKCS1PrivateKeyPEMFormat(privateKey);
  311.                     }catch(Exception ignore) {
  312.                         // rilancio eccezione precedente
  313.                         throw new UtilsException(e.getMessage(),e);
  314.                     }
  315.                 }   
  316.             }
  317.             else if(pemArchive.isPkcs8()) {
  318.                 return this.readPKCS8PrivateKeyPEMFormat(privateKey);
  319.             }
  320.         }
  321.                 
  322.         try {
  323.             return readPKCS8EncryptedPrivateKeyDERFormat(privateKey, password);
  324.         }catch(Exception e) {
  325.             // provo senza password
  326.             try {
  327.                 return readPKCS8PrivateKeyDERFormat(privateKey);
  328.             }catch(Exception ignore) {
  329.                 // rilancio eccezione precedente
  330.                 throw new UtilsException(e.getMessage(),e);
  331.             }
  332.         }
  333.         
  334.     }

  336.     
  337. }
Created with JaCoCo 0.8.8.202204050719