X509Utils.java

  1. /*
  2.  * Copyright (C) 2020-2024 by Savoir-faire Linux
  3.  *
  4.  * This program is free software; you can redistribute it and/or modify
  5.  * it under the terms of the GNU General Public License as published by
  6.  * the Free Software Foundation; either version 3 of the License, or
  7.  * (at your option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  16.  */
  17. package net.jami.jams.common.utils;

  19. import com.google.gson.Gson;

  21. import lombok.extern.slf4j.Slf4j;

  23. import net.jami.jams.common.serialization.adapters.GsonFactory;
  24. import net.jami.jams.common.updater.subscription.LicenseInformation;

  26. import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;
  27. import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;
  28. import org.bouncycastle.openssl.PEMKeyPair;
  29. import org.bouncycastle.openssl.PEMParser;
  30. import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter;
  31. import org.bouncycastle.pkcs.PKCS10CertificationRequest;

  33. import java.io.BufferedReader;
  34. import java.io.ByteArrayInputStream;
  35. import java.io.InputStream;
  36. import java.io.InputStreamReader;
  37. import java.io.StringReader;
  38. import java.nio.charset.StandardCharsets;
  39. import java.security.KeyFactory;
  40. import java.security.PrivateKey;
  41. import java.security.PublicKey;
  42. import java.security.cert.CertificateFactory;
  43. import java.security.cert.X509Certificate;
  44. import java.security.spec.PKCS8EncodedKeySpec;
  45. import java.util.Base64;
  46. import java.util.HashMap;
  47. import java.util.Vector;

  49. import javax.naming.ldap.LdapName;
  50. import javax.naming.ldap.Rdn;

  52. @Slf4j
  53. public class X509Utils {

  55.     private static final String PVK_HEADER = "-----BEGIN PRIVATE KEY-----\n";
  56.     private static final String PVK_TAIL = "\n-----END PRIVATE KEY-----";
  57.     private static final String CERT_HEADER = "-----BEGIN CERTIFICATE-----\n";
  58.     private static final String CERT_TAIL = "\n-----END CERTIFICATE-----";
  59.     private static final String PPK_HEADER = "-----BEGIN PUBLIC KEY-----\n";
  60.     private static final String PPK_TAIL = "\n-----END PUBLIC KEY-----";

  62.     public static PrivateKey getKeyFromPEMString(String keyString) {
  63.         if (keyString.isEmpty()) return null;

  65.         try {
  66.             PEMParser parser = new PEMParser(new StringReader(keyString));
  67.             Object parsedObject = parser.readObject();
  68.             if (parsedObject instanceof PEMKeyPair) {
  69.                 PEMKeyPair pk = (PEMKeyPair) parsedObject;
  70.                 PKCS8EncodedKeySpec keySpec =
  71.                         new PKCS8EncodedKeySpec(pk.getPrivateKeyInfo().getEncoded());
  72.                 return KeyFactory.getInstance("RSA").generatePrivate(keySpec);
  73.             } else {
  74.                 JcaPEMKeyConverter converter = new JcaPEMKeyConverter();
  75.                 return converter.getPrivateKey((PrivateKeyInfo) parsedObject);
  76.             }
  77.         } catch (Exception e) {
  78.             log.error(
  79.                     "An error occurred while converting the PEM to PrivateKey, stack trace: " + e);
  80.             return null;
  81.         }
  82.     }

  84.     public static PublicKey getPubKeyFromPEMString(String keyString) {
  85.         try {
  86.             PEMParser parser = new PEMParser(new StringReader(keyString));
  87.             Object parsedObject = parser.readObject();
  88.             if (parsedObject instanceof PEMKeyPair) {
  89.                 PEMKeyPair pk = (PEMKeyPair) parsedObject;
  90.                 PKCS8EncodedKeySpec keySpec =
  91.                         new PKCS8EncodedKeySpec(pk.getPublicKeyInfo().getEncoded());
  92.                 return KeyFactory.getInstance("RSA").generatePublic(keySpec);
  93.             } else {
  94.                 JcaPEMKeyConverter converter = new JcaPEMKeyConverter();
  95.                 return converter.getPublicKey((SubjectPublicKeyInfo) parsedObject);
  96.             }
  97.         } catch (Exception e) {
  98.             log.error("An error occurred while reading the public key from string!");
  99.             return null;
  100.         }
  101.     }

  103.     public static X509Certificate getCertificateFromPEMString(String certificateString) {
  104.         try {
  105.             CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
  106.             InputStream inputStream = new ByteArrayInputStream(certificateString.getBytes());
  107.             return (X509Certificate) certificateFactory.generateCertificate(inputStream);
  108.         } catch (Exception e) {
  109.             log.error("An error occurred while converting the PEM to X509, stack trace: " + e);
  110.             return null;
  111.         }
  112.     }

  114.     public static String getPEMStringFromPrivateKey(PrivateKey privateKey) {
  115.         StringBuilder stringBuilder = new StringBuilder();
  116.         try {
  117.             stringBuilder.append(PVK_HEADER);
  118.             stringBuilder.append(Base64.getEncoder().encodeToString(privateKey.getEncoded()));
  119.             stringBuilder.append(PVK_TAIL);
  120.             return stringBuilder.toString();
  121.         } catch (Exception e) {
  122.             log.error(
  123.                     "An error occurred while converting the Private Key to PEM, stack trace: " + e);
  124.             return null;
  125.         }
  126.     }

  128.     public static String getPEMStringFromCertificate(X509Certificate certificate) {
  129.         StringBuilder stringBuilder = new StringBuilder();
  130.         try {
  131.             stringBuilder.append(CERT_HEADER);
  132.             stringBuilder.append(Base64.getEncoder().encodeToString(certificate.getEncoded()));
  133.             stringBuilder.append(CERT_TAIL);
  134.             return stringBuilder.toString();
  135.         } catch (Exception e) {
  136.             log.error(
  137.                     "An error occurred while converting the Certificate Key to PEM, stack trace: "
  138.                             + e);
  139.             return null;
  140.         }
  141.     }

  143.     public static String getPEMStringFromPubKey(PublicKey publicKey) {
  144.         StringBuilder stringBuilder = new StringBuilder();
  145.         try {
  146.             stringBuilder.append(PPK_HEADER);
  147.             stringBuilder.append(Base64.getEncoder().encodeToString(publicKey.getEncoded()));
  148.             stringBuilder.append(PPK_TAIL);
  149.             return stringBuilder.toString();
  150.         } catch (Exception e) {
  151.             log.error(
  152.                     "An error occurred while converting the Public Key to PEM, stack trace: " + e);
  153.             return null;
  154.         }
  155.     }

  157.     public static PKCS10CertificationRequest getCSRFromString(String pkcs10StringRequest) {
  158.         try {
  159.             ByteArrayInputStream pemStream =
  160.                     new ByteArrayInputStream(pkcs10StringRequest.getBytes(StandardCharsets.UTF_8));
  161.             PEMParser pemParser =
  162.                     new PEMParser(new BufferedReader(new InputStreamReader(pemStream)));
  163.             Object parsedObj = pemParser.readObject();
  164.             if (parsedObj instanceof PKCS10CertificationRequest)
  165.                 return (PKCS10CertificationRequest) parsedObj;
  166.             log.error("The request does not seem to be a CSR request!");
  167.             return null;
  168.         } catch (Exception e) {
  169.             log.error(
  170.                     "An error occurred while converting the string to PKCS10 Certification Request, stack trace: "
  171.                             + e);
  172.             return null;
  173.         }
  174.     }

  176.     public static Vector<Object> loadLicenseFromDatFile(String fileContents) {
  177.         Vector<Object> res = new Vector<>();
  178.         String keypair = new String(Base64.getDecoder().decode(fileContents));
  179.         int cutPoint = keypair.indexOf("-----BEGIN PRIVATE KEY-----");
  180.         String strCertificate = keypair.substring(0, cutPoint);
  181.         String strPrivateKey = keypair.substring(cutPoint);
  182.         res.add(getCertificateFromPEMString(strCertificate));
  183.         res.add(getKeyFromPEMString(strPrivateKey));
  184.         return res;
  185.     }

  187.     public static LicenseInformation extractSubscriptionTypeFromCertificate(
  188.             X509Certificate certificate) {
  189.         try {
  190.             LdapName ln = new LdapName(certificate.getSubjectDN().toString());
  191.             for (Rdn rdn : ln.getRdns()) {
  192.                 try {
  193.                     Gson gson = GsonFactory.createGson();
  194.                     byte[] bytes = Base64.getDecoder().decode(rdn.getValue().toString().getBytes());
  195.                     return gson.fromJson(new String(bytes, "US-ASCII"), LicenseInformation.class);
  196.                 } catch (Exception e) {
  197.                 }
  198.             }
  199.             return null;
  200.         } catch (Exception e) {
  201.             return null;
  202.         }
  203.     }

  205.     public static HashMap<String, String> extractDNFromCertificate(X509Certificate certificate)
  206.             throws Exception {
  207.         HashMap<String, String> subjectMap = new HashMap<>();
  208.         LdapName ln = new LdapName(certificate.getSubjectDN().toString());
  209.         for (Rdn rdn : ln.getRdns()) {
  210.             subjectMap.put(rdn.getType(), rdn.getValue().toString());
  211.         }
  212.         return subjectMap;
  213.     }
  214. }
Created with JaCoCo 0.8.11.202310140853