org.bouncycastle.openssl.jcajce.JcaPEMWriter Java Examples

/**
 * Returns the Certificate as a PEM encoded String.
 *
 * @param certificate - X.509 Certificate.
 * @return PEM Encoded Certificate String.
 * @throws SCMSecurityException - On failure to create a PEM String.
 */
public static String getPEMEncodedString(X509Certificate certificate)
    throws SCMSecurityException {
  try {
    StringWriter stringWriter = new StringWriter();
    try (JcaPEMWriter pemWriter = new JcaPEMWriter(stringWriter)) {
      pemWriter.writeObject(certificate);
    }
    return stringWriter.toString();
  } catch (IOException e) {
    LOG.error("Error in encoding certificate." + certificate
        .getSubjectDN().toString(), e);
    throw new SCMSecurityException("PEM Encoding failed for certificate." +
        certificate.getSubjectDN().toString(), e);
  }
}
 

/**
 * Encode an X509 certificate into PEM format.
 *
 * @param certificate The certificate to encode.
 * @return the PEM encoded certificate, or {@code null} if the input was {@code null}.
 */
public static String toPem(final X509Certificate... certificates) {

    if (certificates == null) {
        return null;
    }

    final StringWriter sw = new StringWriter();

    try (JcaPEMWriter pw = new JcaPEMWriter(sw)) {
        for (X509Certificate certificate : certificates) {
            pw.writeObject(certificate);
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    }

    return sw.toString();

}
 

private static String toPkcs1Pem(PrivateKey privateKey) {
    try (StringWriter stringWriter = new StringWriter(); JcaPEMWriter pemWriter = new JcaPEMWriter(stringWriter)) {
        String algorithm = privateKey.getAlgorithm();
        String type;
        if (algorithm.equals(RSA.getAlgorithmName())) {
            type = "RSA PRIVATE KEY";
        } else if (algorithm.equals(EC.getAlgorithmName())) {
            type = "EC PRIVATE KEY";
        } else {
            throw new IllegalArgumentException("Unexpected key algorithm: " + algorithm);
        }
        pemWriter.writeObject(new PemObject(type, getPkcs1Bytes(privateKey)));
        pemWriter.flush();
        return stringWriter.toString();
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

public String convertX509CertToPem( X509Certificate x509Cert )
{
    try
    {
        StringWriter sw = new StringWriter();
        try ( JcaPEMWriter pw = new JcaPEMWriter( sw ) )
        {
            pw.writeObject( x509Cert );
        }
        return sw.toString();
    }
    catch ( IOException e )
    {
        throw new ActionFailedException( "Failed to convert certificate to PEM", e );
    }
}
 

/***
 * Creates a TLSCertificateKeyPair out of the given {@link X509Certificate} and {@link KeyPair}
 * encoded in PEM and also in DER for the certificate
 * @param x509Cert the certificate to process
 * @param keyPair  the key pair to process
 * @return a TLSCertificateKeyPair
 * @throws IOException upon failure
 */
static TLSCertificateKeyPair fromX509CertKeyPair(X509Certificate x509Cert, KeyPair keyPair) throws IOException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    PrintWriter writer = new PrintWriter(baos);
    JcaPEMWriter w = new JcaPEMWriter(writer);
    w.writeObject(x509Cert);
    w.flush();
    w.close();
    byte[] pemBytes = baos.toByteArray();

    InputStreamReader isr = new InputStreamReader(new ByteArrayInputStream(pemBytes));
    PemReader pr = new PemReader(isr);
    PemObject pem = pr.readPemObject();
    byte[] derBytes = pem.getContent();

    baos = new ByteArrayOutputStream();
    PrintWriter wr = new PrintWriter(baos);
    wr.println("-----BEGIN PRIVATE KEY-----");
    wr.println(new String(Base64.encodeBase64(keyPair.getPrivate().getEncoded())));
    wr.println("-----END PRIVATE KEY-----");
    wr.flush();
    wr.close();
    byte[] keyBytes = baos.toByteArray();
    return new TLSCertificateKeyPair(pemBytes, derBytes, keyBytes);
}
 

/**
 * 不支持sm2
 *
 * @param privateKey  私钥
 * @param savePath    保存路径
 * @param password    加密保存密码
 * @param encryptType 加密类型 默认DES-EDE3-CBC
 * @throws CertException
 */
public static void savePrivateKeyPem(PrivateKey privateKey, String savePath, String password, String encryptType)
        throws CertException {
    try {
        if (null == privateKey) {
            throw new CertException("privateKey can't be null");
        }
        if (null == password) {
            throw new CertException("password can't be null");
        }
        if (null == savePath) {
            throw new CertException("savePath can't be null");
        }
        if (null == encryptType) {
            encryptType = "DES-EDE3-CBC";
        }
        JcaPEMWriter jcaPEMWriter = new JcaPEMWriter(new FileWriter(savePath));
        jcaPEMWriter.writeObject(privateKey, new JcePEMEncryptorBuilder(encryptType).build(password.toCharArray()));
        jcaPEMWriter.close();
    } catch (Exception e) {
        throw new CertException("save privateKey failed", e);
    }
}
 

/**
 * 明文保存 privateKey
 *
 * @param privateKey
 * @param savePath
 * @throws CertException
 */
public static void savePrivateKeyPem(final PrivateKey privateKey, String savePath) throws CertException {
    try {
        if (null == privateKey) {
            throw new CertException("privateKey can't be null");
        }
        if (null == savePath) {
            throw new CertException(" savePath can't be null");
        }
        JcaPEMWriter jcaPEMWriter = new JcaPEMWriter(new FileWriter(savePath));
        jcaPEMWriter.writeObject(privateKey);
        jcaPEMWriter.close();
    } catch (Exception e) {
        throw new CertException("save privateKey failed", e);
    }
}
 

/**
 * 明文保存 publicKey
 *
 * @param publicKey
 * @param savePath
 * @throws CertException
 */
public static void savePublicKeyPem(final PublicKey publicKey, String savePath) throws CertException {
    try {
        if (null == publicKey) {
            throw new CertException("publicKey can't be null");
        }
        if (null == savePath) {
            throw new CertException(" savePath can't be null");
        }
        JcaPEMWriter jcaPEMWriter = new JcaPEMWriter(new FileWriter(savePath));
        jcaPEMWriter.writeObject(publicKey);
        jcaPEMWriter.close();
    } catch (Exception e) {
        throw new CertException("save publicKey failed", e);
    }
}
 

/**
 * 保存公钥证书 base64编码
 *
 * @param cert
 * @param savePath
 * @throws Exception
 */
public static void saveX509CertBase64(final X509Certificate cert, String savePath) throws Exception {

    try {
        if (null == cert) {
            throw new CertException("cert can't be null");
        }
        if (null == savePath) {
            throw new CertException(" savePath can't be null");
        }
        JcaPEMWriter jcaPEMWriter = new JcaPEMWriter(new FileWriter(savePath));
        jcaPEMWriter.writeObject(cert, null);
        jcaPEMWriter.close();
    } catch (Exception e) {
        throw new CertException("save cert failed", e);
    }
}
 

public void writePemPublicToFile(String path)
{
    try
    {
        File f = new File(path);
        if (!f.getParentFile().isDirectory() && !f.getParentFile().mkdir())
        {
            throw new PkiException(
                    "couldn't create directory " + f.getParentFile().getAbsolutePath() + " for storing the SSL keystore");
        }
        try (FileWriter fw = new FileWriter(path);
             JcaPEMWriter wr = new JcaPEMWriter(fw))
        {
            wr.writeObject(holder);
            wr.flush();
        }
    }
    catch (Exception e)
    {
        throw new PkiException(e);
    }
}
 

public static String getEncodedString(PKCS10CertificationRequest request)
    throws IOException {
  PemObject pemObject =
      new PemObject("CERTIFICATE REQUEST", request.getEncoded());
  StringWriter str = new StringWriter();
  try(JcaPEMWriter pemWriter = new JcaPEMWriter(str)) {
    pemWriter.writeObject(pemObject);
  }
  return str.toString();
}
 

/**
 * Serialize a certificate into a PEM formatted String.
 *
 * @param certificate the certificate to be serialized.
 * @return the certificate in PEM format
 * @throws IOException thrown if the certificate cannot be converted into the PEM format.
 */
public static String serializeCertificateInPEM(final Certificate certificate) throws IOException {
  StringWriter buff = new StringWriter();
  try (JcaPEMWriter writer = new JcaPEMWriter(buff)) {
    writer.writeObject(certificate);
  }
  return buff.toString();
}
 

public void saveToPemFile(File file) throws FileNotFoundException, IOException {
    try (JcaPEMWriter pem = new JcaPEMWriter(new OutputStreamWriter(new FileOutputStream(file)))) {
        for (Object object : buildList) {
            pem.writeObject(object);
        }
        pem.close();
    }
}
 

/**
 * Encodes the specified security object in PEM format, using the specified encryptor. If the encryptor is null,
 * the object will not be encrypted in the generated String.
 *
 * @param object    object to encrypt (certificate, private key, etc.)
 * @param encryptor engine to encrypt the resulting PEM String, or null if no encryption should be used
 * @return a PEM-encoded String
 */
private static String encodeObjectAsPemString(Object object, PEMEncryptor encryptor) {
    StringWriter stringWriter = new StringWriter();

    try (JcaPEMWriter pemWriter = new JcaPEMWriter(stringWriter)) {
        pemWriter.writeObject(object, encryptor);
        pemWriter.flush();
    } catch (IOException e) {
        throw new ExportException("Unable to generate PEM string representing object", e);
    }

    return stringWriter.toString();
}
 

static CertificateModule createCertificateModuleForPem(Object... objects) throws Exception {
  ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
  try (JcaPEMWriter pemWriter =
      new JcaPEMWriter(new OutputStreamWriter(byteArrayOutputStream, UTF_8))) {
    for (Object object : objects) {
      pemWriter.writeObject(object);
    }
  }
  return new CertificateModule(byteArrayOutputStream.toByteArray());
}
 

public static String x509CertificatesToPEM(X509Certificate[] x509Certs) throws CryptoException {
    StringWriter sw = new StringWriter();
    try (JcaPEMWriter pw = new JcaPEMWriter(sw)) {
        for (X509Certificate x509Cert : x509Certs) {
            pw.writeObject(x509Cert);
        }
    } catch (IOException ex) {
        LOG.error("Unable to generate PEM output", ex);
        throw new CryptoException(ex);
    }
    return sw.toString();
}
 

public static String generateX509CSR(PrivateKey privateKey, PublicKey publicKey,
                                     String x500Principal, GeneralName[] sanArray) throws OperatorCreationException, IOException {

    // Create Distinguished Name

    X500Principal subject = new X500Principal(x500Principal);

    // Create ContentSigner

    JcaContentSignerBuilder csBuilder = new JcaContentSignerBuilder(Crypto.RSA_SHA256);
    ContentSigner signer = csBuilder.build(privateKey);

    // Create the CSR

    PKCS10CertificationRequestBuilder p10Builder = new JcaPKCS10CertificationRequestBuilder(
            subject, publicKey);

    // Add SubjectAlternativeNames (SAN) if specified
    ///CLOVER:OFF
    if (sanArray != null) {
        ///CLOVER:ON
        ExtensionsGenerator extGen = new ExtensionsGenerator();
        GeneralNames subjectAltNames = new GeneralNames(sanArray);
        extGen.addExtension(Extension.subjectAlternativeName, false, subjectAltNames);
        p10Builder.addAttribute(PKCSObjectIdentifiers.pkcs_9_at_extensionRequest, extGen.generate());
    }

    PKCS10CertificationRequest csr = p10Builder.build(signer);

    // write to openssl PEM format

    PemObject pemObject = new PemObject("CERTIFICATE REQUEST", csr.getEncoded());
    StringWriter strWriter;
    try (JcaPEMWriter pemWriter = new JcaPEMWriter(strWriter = new StringWriter())) {
        pemWriter.writeObject(pemObject);
    }
    return strWriter.toString();
}
 

public static String convertToPEMFormat(Object obj) {
    StringWriter writer = new StringWriter();
    try {
        try (JcaPEMWriter pemWriter = new JcaPEMWriter(writer)) {
            pemWriter.writeObject(obj);
            pemWriter.flush();
        }
        ///CLOVER:OFF
    } catch (IOException ex) {
        LOG.error("convertToPEMFormat: unable to convert object to PEM: " + ex.getMessage());
        return null;
    }
    ///CLOVER:ON
    return writer.toString();
}
 

private void generatePem()
{
    try
    {
        // PEM public key
        pemPublicFile = new ByteArrayOutputStream();

        try (Writer osw = new OutputStreamWriter(pemPublicFile);
             JcaPEMWriter wr = new  JcaPEMWriter(osw))
        {
            wr.writeObject(holder);
            wr.flush();
        }

        // PEM private key
        pemPrivateFile = new ByteArrayOutputStream();

        try (Writer osw = new OutputStreamWriter(pemPrivateFile);
             JcaPEMWriter wr = new JcaPEMWriter(osw))
        {
            wr.writeObject(privateKey);
            wr.flush();
        }
    }
    catch (Exception e)
    {
        throw new PkiException(e);
    }
}
 

public static String pemOf(final Object pemObject) throws IOException {
  final StringWriter sw = new StringWriter();
  final JcaPEMWriter writer = new JcaPEMWriter(sw);
  writer.writeObject(pemObject);
  writer.close();
  return sw.toString();
}
 

public String writePemPrivateToString()
{
    try (StringWriter sw = new StringWriter();
         JcaPEMWriter wr = new JcaPEMWriter(sw))
    {
        wr.writeObject(privateKey);
        wr.flush();
        return sw.toString();
    }
    catch (Exception e)
    {
        throw new PkiException(e);
    }
}
 

private static void outputAsPem(Object pemObj, String filename, File directory, String extension) throws IOException {
    OutputStream outputStream = new FileOutputStream(new File(directory,  TlsHelper.escapeFilename(filename) + extension));
    OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream);
    JcaPEMWriter pemWriter = new JcaPEMWriter(outputStreamWriter);
    JcaMiscPEMGenerator pemGen = new JcaMiscPEMGenerator(pemObj);
    pemWriter.writeObject(pemGen);
    pemWriter.close();
}
 

/**
 * Helper method for exporting PEM object.
 * 
 * @param object
 *            to export in PEM format.
 * @param filename
 *            for the file to export.
 */
public void exportPEMObject(Object pemObject, String filename) throws IOException {
	Writer writer;
	writer = new FileWriter(filename);
	JcaPEMWriter jcaPemWriter = new JcaPEMWriter(writer);
	jcaPemWriter.writeObject(pemObject);
	jcaPemWriter.flush();
	jcaPemWriter.close();
}
 

@Override
public String printKey() {
  final StringWriter sw = new StringWriter();
  try {
    try (JcaPEMWriter writer = new JcaPEMWriter(sw)) {
      writer.writeObject(privateKey);
      writer.flush();
      return sw.toString();
    }
  } catch (final IOException e) {
    throw new CaException(e);
  }
}
 

@Override
public void saveKey(File file) {
  try {
    try (BufferedWriter fw = Files.newBufferedWriter(file.toPath(), StandardCharsets.UTF_8,
        StandardOpenOption.CREATE)) {
      try (JcaPEMWriter writer = new JcaPEMWriter(fw)) {
        writer.writeObject(privateKey);
        writer.flush();
      }
    }
  } catch (final IOException e) {
    throw new CaException(e);
  }
}
 

@Override
public String print() {
  final StringWriter sw = new StringWriter();
  try {
    try (JcaPEMWriter writer = new JcaPEMWriter(sw)) {
      writer.writeObject(certificate);
      writer.flush();
      return sw.toString();
    }
  } catch (final IOException e) {
    throw new CaException(e);
  }
}
 

@Override
public void save(final File file) {
  try {
    try (BufferedWriter fw = Files.newBufferedWriter(file.toPath(), StandardCharsets.UTF_8,
        StandardOpenOption.CREATE)) {
      try (JcaPEMWriter writer = new JcaPEMWriter(fw)) {
        writer.writeObject(certificate);
        writer.flush();
      }
    }
  } catch (final IOException e) {
    throw new CaException(e);
  }
}
 

public void writePemPrivateToFile(String path)
{
    try (FileWriter fw = new FileWriter(path);
         JcaPEMWriter wr = new JcaPEMWriter(fw))
    {
        wr.writeObject(privateKey);
        wr.flush();
    }
    catch (Exception e)
    {
        throw new PkiException(e);
    }
}
 

public String writePemPublicToString()
{
    try (StringWriter sw = new StringWriter();
         JcaPEMWriter wr = new JcaPEMWriter(sw))
    {
        wr.writeObject(holder);
        wr.flush();
        return sw.toString();
    }
    catch (Exception e)
    {
        throw new PkiException(e);
    }
}
 

public static String x509CertificateToPem(final X509Certificate cert) throws IOException {
    final StringWriter sw = new StringWriter();
    try (final JcaPEMWriter pw = new JcaPEMWriter(sw)) {
        pw.writeObject(cert);
        pw.flush();
    }
    return sw.toString();
}