Example usage for org.bouncycastle.openssl.jcajce JcaPEMWriter writeObject

List of usage examples for org.bouncycastle.openssl.jcajce JcaPEMWriter writeObject

Introduction

In this page you can find the example usage for org.bouncycastle.openssl.jcajce JcaPEMWriter writeObject.

Prototype

public void writeObject(PemObjectGenerator obj) throws IOException 

Source Link

Usage

From source file:AAModulePackage.ACHelper.java

/**
 * Pretty simple. Take the input X.509 AC and write it out to a .PEM file.
 * @param cert - X.509 Attribute Certificate
 * @param fileName - Full path/filename for the AC.
 *///w w w .  j  a  v a  2 s . c om
public static void saveAttributeCertToFile(X509AttributeCertificateHolder cert, String fileName) {
    File atrCertFile = new File(fileName);
    JcaPEMWriter pw = null;
    try {
        pw = new JcaPEMWriter(new FileWriter(atrCertFile));
        pw.writeObject(cert);
        pw.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

From source file:beta01.CertSigningRequest.java

private void genaretKeyPairDsa() throws Exception {
    String signatureAlg = "SHA1withDSA";
    KeyPairGenerator kpg = KeyPairGenerator.getInstance("DSA", "BC");
    kpg.initialize(2048);/*from  www .  j  a v a 2s . co m*/
    KeyPair kp = kpg.genKeyPair();

    X500NameBuilder x500NameBuilder = new X500NameBuilder(BCStyle.INSTANCE);
    x500NameBuilder.addRDN(BCStyle.C, "ID");
    x500NameBuilder.addRDN(BCStyle.CN, "Pizaini");
    //x500NameBuilder.addRDN(BCStyle.O, "Institut Pertanian Bogor");

    X500Name subject = x500NameBuilder.build();

    PKCS10CertificationRequestBuilder requestBuilder = new JcaPKCS10CertificationRequestBuilder(subject,
            kp.getPublic());
    try {
        PKCS10CertificationRequest request = requestBuilder
                .build(new JcaContentSignerBuilder(signatureAlg).setProvider("BC").build(kp.getPrivate()));

        //verify signature
        if (request.isSignatureValid(
                new JcaContentVerifierProviderBuilder().setProvider("BC").build(kp.getPublic()))) {
            System.out.println(signatureAlg + ": PKCS#10 request verified.");
            //CSR Output
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            //PemWriter pemWrtb = new PemWriter(new OutputStreamWriter(baos));
            JcaPEMWriter jcaPem = new JcaPEMWriter(new OutputStreamWriter(baos));
            jcaPem.writeObject(request);
            jcaPem.close();
            try {
                File file = new File("D:\\CSR_" + kpg.getAlgorithm() + ".p10");
                FileOutputStream fos = new FileOutputStream(file);
                baos.close();
                fos.write(baos.toByteArray());
                fos.flush();
                fos.close();
            } catch (IOException ex) {

            }

            //store Private Key p8   
            try {
                File file = new File("D:\\PrivateKey_" + kpg.getAlgorithm() + ".p8");
                FileOutputStream fos = new FileOutputStream(file);
                fos.write(kp.getPrivate().getEncoded());
                fos.flush();
                fos.close();
                System.out.println("Privated key stored as " + kp.getPrivate().getFormat());
            } catch (IOException ex) {
            }

            //p12
            /*KeyStore pkcs12 = KeyStore.getInstance("PKCS12", "BC");
            pkcs12.load(null, null);
            //pkcs12.setCertificateEntry("r2oot", holderRoot);
            pkcs12.setKeyEntry("PIZAINI_ECDSA", kp.getPrivate(), null, null);
            char[] password = "pass".toCharArray();
            ByteArrayOutputStream bOut = new ByteArrayOutputStream();
            pkcs12.store(bOut, password);
                    
            ASN1InputStream asnInput = new ASN1InputStream(bOut.toByteArray());
            bOut.reset();
            DEROutputStream derOut = new DEROutputStream(bOut);
            derOut.writeObject(asnInput.readObject());
            byte[] derFormat = bOut.toByteArray();
            try{
            File file = new File("D:\\Pizaini_ECDSA_Private.p12");
            FileOutputStream fos = new FileOutputStream(file);
            bOut.close();
            fos.write(derFormat);
            fos.flush();
            fos.close();
            }catch(IOException ex){
                    
            }*/

        } else {
            System.out.println(signatureAlg + ": Failed verify check.");
        }
    } catch (OperatorCreationException | PKCSException ex) {

    }

}

From source file:beta01.SimpleGenCert.java

public void converToPem(X509CertificateHolder holder, String fileName)
        throws CertificateException, IOException {
    X509Certificate cert;/*from w  w  w  .  java 2  s . c  o  m*/
    cert = toX509Certificate(holder);
    System.out.println(
            "Subject: " + cert.getSubjectX500Principal() + " - Issuer: " + cert.getIssuerX500Principal());

    //convert
    ByteArrayOutputStream bOut = new ByteArrayOutputStream();
    JcaPEMWriter pemWrt = new JcaPEMWriter(new OutputStreamWriter(bOut));
    pemWrt.writeObject(cert);
    pemWrt.close();

    //write to file
    try {
        File file = new File("D:\\" + fileName + ".cer");
        FileOutputStream fos = new FileOutputStream(file);
        bOut.close();
        fos.write(bOut.toByteArray());
        fos.flush();
        fos.close();
    } catch (IOException ex) {

    }

    //System.out.println(new String(bOut.toByteArray()));
}

From source file:CAModulePackage.CertificateHelper.java

/**
 * Pretty basic. Saves an X.509 Certificate to a .PEM File
 * @param cert - X.509 Certificate to be saved
 * @param filename - Full path/filename for the certificate file.
 *//*from ww w.j  a v  a 2  s .c  om*/
public static void saveCertToFile(X509CertificateHolder cert, String filename) {
    JcaPEMWriter pw = null;
    try {
        pw = new JcaPEMWriter(new FileWriter(new File(filename)));
        pw.writeObject(cert);
        pw.close();
    } catch (IOException e) {
        e.printStackTrace();
    }

}

From source file:cf.monteux.silvertunnel.netlib.layer.tor.util.Encryption.java

License:Open Source License

/**
 * Converts RSA private key to PEM string.
 *
 * @param rsaKeyPair/*ww w.j a  va  2s .  c o  m*/
 * @return PEM string
 */
public static String getPEMStringFromRSAKeyPair(final RSAKeyPair rsaKeyPair) {
    final StringWriter pemStrWriter = new StringWriter();
    final JcaPEMWriter pemWriter = new JcaPEMWriter(pemStrWriter);
    try {
        final KeyPair keyPair = new KeyPair(rsaKeyPair.getPublic(), rsaKeyPair.getPrivate());
        pemWriter.writeObject(keyPair.getPrivate());
        pemWriter.close();

    } catch (final IOException e) {
        logger.warn("Caught exception:" + e.getMessage());
        return "";
    }

    return pemStrWriter.toString();
}

From source file:com.cws.esolutions.security.dao.certmgmt.impl.CertificateManagerImpl.java

License:Apache License

/**
 * @see com.cws.esolutions.security.dao.certmgmt.interfaces.ICertificateManager#createCertificateRequest(List, String, int, int)
 *//* w  ww  . j av  a 2  s.  co m*/
public synchronized File createCertificateRequest(final List<String> subjectData, final String storePassword,
        final int validityPeriod, final int keySize) throws CertificateManagementException {
    final String methodName = ICertificateManager.CNAME
            + "#createCertificateRequest(final List<String> subjectData, final String storePassword, final int validityPeriod, final int keySize) throws CertificateManagementException";

    if (DEBUG) {
        DEBUGGER.debug(methodName);
        DEBUGGER.debug("Value: {}", subjectData);
        DEBUGGER.debug("Value: {}", validityPeriod);
        DEBUGGER.debug("Value: {}", keySize);
    }

    final File rootDirectory = certConfig.getRootDirectory();
    final String signatureAlgorithm = certConfig.getSignatureAlgorithm();
    final String certificateAlgorithm = certConfig.getCertificateAlgorithm();
    final File privateKeyDirectory = FileUtils
            .getFile(certConfig.getPrivateKeyDirectory() + "/" + subjectData.get(0));
    final File publicKeyDirectory = FileUtils
            .getFile(certConfig.getPublicKeyDirectory() + "/" + subjectData.get(0));
    final File csrDirectory = FileUtils.getFile(certConfig.getCsrDirectory() + "/" + subjectData.get(0));
    final File storeDirectory = FileUtils.getFile(certConfig.getStoreDirectory() + "/" + subjectData.get(0));
    final X500Name x500Name = new X500Name("CN=" + subjectData.get(0) + ",OU=" + subjectData.get(1) + ",O="
            + subjectData.get(2) + ",L=" + subjectData.get(3) + ",ST=" + subjectData.get(4) + ",C="
            + subjectData.get(5) + ",E=" + subjectData.get(6));

    if (DEBUG) {
        DEBUGGER.debug("rootDirectory: {}", rootDirectory);
        DEBUGGER.debug("signatureAlgorithm: {}", signatureAlgorithm);
        DEBUGGER.debug("certificateAlgorithm: {}", certificateAlgorithm);
        DEBUGGER.debug("privateKeyDirectory: {}", privateKeyDirectory);
        DEBUGGER.debug("publicKeyDirectory: {}", publicKeyDirectory);
        DEBUGGER.debug("csrDirectory: {}", csrDirectory);
        DEBUGGER.debug("storeDirectory: {}", storeDirectory);
        DEBUGGER.debug("x500Name: {}", x500Name);
    }

    File csrFile = null;
    JcaPEMWriter csrPemWriter = null;
    JcaPEMWriter publicKeyWriter = null;
    JcaPEMWriter privateKeyWriter = null;
    FileOutputStream csrFileStream = null;
    FileOutputStream keyStoreStream = null;
    FileOutputStream publicKeyFileStream = null;
    FileOutputStream privateKeyFileStream = null;
    OutputStreamWriter csrFileStreamWriter = null;
    OutputStreamWriter privateKeyStreamWriter = null;
    OutputStreamWriter publicKeyStreamWriter = null;

    try {
        KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
        keyStore.load(null, storePassword.toCharArray());

        if (DEBUG) {
            DEBUGGER.debug("KeyStore: {}", keyStore);
        }

        SecureRandom random = new SecureRandom();
        KeyPairGenerator keyGenerator = KeyPairGenerator.getInstance(certificateAlgorithm);
        keyGenerator.initialize(keySize, random);

        if (DEBUG) {
            DEBUGGER.debug("KeyGenerator: {}", keyGenerator);
        }

        KeyPair keyPair = keyGenerator.generateKeyPair();

        if (DEBUG) {
            DEBUGGER.debug("KeyPair: {}", keyPair);
        }

        if (keyPair != null) {
            final Signature sig = Signature.getInstance(signatureAlgorithm);
            final PrivateKey privateKey = keyPair.getPrivate();
            final PublicKey publicKey = keyPair.getPublic();

            if (DEBUG) {
                DEBUGGER.debug("Signature: {}", sig);
                DEBUGGER.debug("PrivateKey: {}", privateKey);
                DEBUGGER.debug("PublicKey: {}", publicKey);
            }

            sig.initSign(privateKey, random);
            ContentSigner signGen = new JcaContentSignerBuilder(signatureAlgorithm).build(privateKey);

            if (DEBUG) {
                DEBUGGER.debug("ContentSigner: {}", signGen);
            }

            Calendar expiry = Calendar.getInstance();
            expiry.add(Calendar.DAY_OF_YEAR, validityPeriod);

            if (DEBUG) {
                DEBUGGER.debug("Calendar: {}", expiry);
            }

            CertificateFactory certFactory = CertificateFactory.getInstance(certConfig.getCertificateType());

            if (DEBUG) {
                DEBUGGER.debug("CertificateFactory: {}", certFactory);
            }

            X509Certificate[] issuerCert = new X509Certificate[] { (X509Certificate) certFactory
                    .generateCertificate(new FileInputStream(certConfig.getIntermediateCertificateFile())) };

            if (DEBUG) {
                DEBUGGER.debug("X509Certificate[]: {}", (Object) issuerCert);
            }

            keyStore.setCertificateEntry(certConfig.getRootCertificateName(), certFactory.generateCertificate(
                    new FileInputStream(FileUtils.getFile(certConfig.getRootCertificateFile()))));
            keyStore.setCertificateEntry(certConfig.getIntermediateCertificateName(),
                    certFactory.generateCertificate(new FileInputStream(
                            FileUtils.getFile(certConfig.getIntermediateCertificateFile()))));

            PKCS10CertificationRequestBuilder builder = new JcaPKCS10CertificationRequestBuilder(x500Name,
                    publicKey);

            if (DEBUG) {
                DEBUGGER.debug("PKCS10CertificationRequestBuilder: {}", builder);
            }

            PKCS10CertificationRequest csr = builder.build(signGen);

            if (DEBUG) {
                DEBUGGER.debug("PKCS10CertificationRequest: {}", csr);
            }

            // write private key
            File privateKeyFile = FileUtils.getFile(privateKeyDirectory + "/" + subjectData.get(0)
                    + SecurityServiceConstants.PRIVATEKEY_FILE_EXT);

            if (DEBUG) {
                DEBUGGER.debug("privateKeyFile: {}", privateKeyFile);
            }

            if (!(privateKeyFile.createNewFile())) {
                throw new IOException("Failed to store private file");
            }

            privateKeyFileStream = new FileOutputStream(privateKeyFile);
            privateKeyStreamWriter = new OutputStreamWriter(privateKeyFileStream);

            if (DEBUG) {
                DEBUGGER.debug("privateKeyFileStream: {}", privateKeyFileStream);
                DEBUGGER.debug("privateKeyStreamWriter: {}", privateKeyStreamWriter);
            }

            privateKeyWriter = new JcaPEMWriter(privateKeyStreamWriter);
            privateKeyWriter.writeObject(privateKey);
            privateKeyWriter.flush();
            privateKeyStreamWriter.flush();
            privateKeyFileStream.flush();

            // write public key
            File publicKeyFile = FileUtils.getFile(publicKeyDirectory + "/" + subjectData.get(0)
                    + SecurityServiceConstants.PUBLICKEY_FILE_EXT);

            if (DEBUG) {
                DEBUGGER.debug("publicKeyFile: {}", publicKeyFile);
            }

            if (!(publicKeyFile.createNewFile())) {
                throw new IOException("Failed to store public key file");
            }

            publicKeyFileStream = new FileOutputStream(publicKeyFile);
            publicKeyStreamWriter = new OutputStreamWriter(publicKeyFileStream);

            if (DEBUG) {
                DEBUGGER.debug("publicKeyFileStream: {}", publicKeyFileStream);
                DEBUGGER.debug("publicKeyStreamWriter: {}", publicKeyStreamWriter);
            }

            publicKeyWriter = new JcaPEMWriter(publicKeyStreamWriter);
            publicKeyWriter.writeObject(publicKey);
            publicKeyWriter.flush();
            publicKeyStreamWriter.flush();
            publicKeyFileStream.flush();

            // write csr
            csrFile = FileUtils
                    .getFile(csrDirectory + "/" + subjectData.get(0) + SecurityServiceConstants.CSR_FILE_EXT);

            if (DEBUG) {
                DEBUGGER.debug("csrFile: {}", csrFile);
            }

            if (!(csrFile.createNewFile())) {
                throw new IOException("Failed to store CSR file");
            }

            csrFileStream = new FileOutputStream(csrFile);
            csrFileStreamWriter = new OutputStreamWriter(csrFileStream);

            if (DEBUG) {
                DEBUGGER.debug("publicKeyFileStream: {}", publicKeyFileStream);
                DEBUGGER.debug("publicKeyStreamWriter: {}", publicKeyStreamWriter);
            }

            csrPemWriter = new JcaPEMWriter(csrFileStreamWriter);
            csrPemWriter.writeObject(csr);
            csrPemWriter.flush();
            csrFileStreamWriter.flush();
            csrFileStream.flush();

            File keyStoreFile = FileUtils
                    .getFile(storeDirectory + "/" + subjectData.get(0) + "." + KeyStore.getDefaultType());

            if (DEBUG) {
                DEBUGGER.debug("keyStoreFile: {}", keyStoreFile);
            }

            keyStoreStream = FileUtils.openOutputStream(keyStoreFile);

            if (DEBUG) {
                DEBUGGER.debug("keyStoreStream: {}", keyStoreStream);
            }

            keyStore.setKeyEntry(subjectData.get(0), (Key) keyPair.getPrivate(), storePassword.toCharArray(),
                    issuerCert);
            keyStore.store(keyStoreStream, storePassword.toCharArray());
            keyStoreStream.flush();

            if (DEBUG) {
                DEBUGGER.debug("KeyStore: {}", keyStore);
            }
        } else {
            throw new CertificateManagementException("Failed to generate keypair. Cannot continue.");
        }
    } catch (FileNotFoundException fnfx) {
        throw new CertificateManagementException(fnfx.getMessage(), fnfx);
    } catch (IOException iox) {
        throw new CertificateManagementException(iox.getMessage(), iox);
    } catch (NoSuchAlgorithmException nsax) {
        throw new CertificateManagementException(nsax.getMessage(), nsax);
    } catch (IllegalStateException isx) {
        throw new CertificateManagementException(isx.getMessage(), isx);
    } catch (InvalidKeyException ikx) {
        throw new CertificateManagementException(ikx.getMessage(), ikx);
    } catch (OperatorCreationException ocx) {
        throw new CertificateManagementException(ocx.getMessage(), ocx);
    } catch (KeyStoreException ksx) {
        throw new CertificateManagementException(ksx.getMessage(), ksx);
    } catch (CertificateException cx) {
        throw new CertificateManagementException(cx.getMessage(), cx);
    } finally {
        if (csrFileStreamWriter != null) {
            IOUtils.closeQuietly(csrFileStreamWriter);
        }

        if (csrFileStream != null) {
            IOUtils.closeQuietly(csrFileStream);
        }

        if (csrPemWriter != null) {
            IOUtils.closeQuietly(csrPemWriter);
        }

        if (publicKeyFileStream != null) {
            IOUtils.closeQuietly(publicKeyFileStream);
        }

        if (publicKeyStreamWriter != null) {
            IOUtils.closeQuietly(publicKeyStreamWriter);
        }

        if (publicKeyWriter != null) {
            IOUtils.closeQuietly(publicKeyWriter);
        }

        if (privateKeyFileStream != null) {
            IOUtils.closeQuietly(privateKeyFileStream);
        }

        if (privateKeyStreamWriter != null) {
            IOUtils.closeQuietly(privateKeyStreamWriter);
        }

        if (privateKeyWriter != null) {
            IOUtils.closeQuietly(privateKeyWriter);
        }

        if (keyStoreStream != null) {
            IOUtils.closeQuietly(keyStoreStream);
        }
    }

    return csrFile;
}

From source file:com.googlesource.gerrit.convertkey.ConvertKey.java

License:Apache License

public static void main(String[] args) throws GeneralSecurityException, JSchException, IOException {
    SimpleGeneratorHostKeyProvider p;/*from  w ww.  ja v  a2 s  .  c  o  m*/

    if (args.length != 1) {
        System.err.println("Error: requires path to the SSH host key");
        return;
    } else {
        File file = new File(args[0]);
        if (!file.exists() || !file.isFile() || !file.canRead()) {
            System.err.println("Error: ssh key should exist and be readable");
            return;
        }
    }

    p = new SimpleGeneratorHostKeyProvider();
    // Gerrit's SSH "simple" keys are always RSA.
    p.setPath(args[0]);
    p.setAlgorithm("RSA");
    Iterable<KeyPair> keys = p.loadKeys(); // forces the key to generate.
    for (KeyPair k : keys) {
        System.out.println("Public Key (" + k.getPublic().getAlgorithm() + "):");
        // From Gerrit's SshDaemon class; use JSch to get the public
        // key/type
        final Buffer buf = new Buffer();
        buf.putRawPublicKey(k.getPublic());
        final byte[] keyBin = buf.getCompactData();
        HostKey pub = new HostKey("localhost", keyBin);
        System.out.println(pub.getType() + " " + pub.getKey());
        System.out.println("Private Key:");
        // Use Bouncy Castle to write the private key back in PEM format
        // (PKCS#1)
        // http://stackoverflow.com/questions/25129822/export-rsa-public-key-to-pem-string-using-java
        StringWriter privout = new StringWriter();
        JcaPEMWriter privWriter = new JcaPEMWriter(privout);
        privWriter.writeObject(k.getPrivate());
        privWriter.close();
        System.out.println(privout);
    }
}

From source file:com.hypersocket.certs.X509CertificateUtils.java

License:Open Source License

public static void saveKeyPair(KeyPair pair, OutputStream keyfile) throws CertificateException {

    JcaPEMWriter writer = new JcaPEMWriter(new OutputStreamWriter(keyfile));
    try {//w w  w  . j  a va  2  s  . c o  m
        writer.writeObject(pair.getPrivate());
        writer.flush();
        writer.close();
    } catch (IOException e) {
        throw new CertificateException("Failed to save key pair", e);
    }
}

From source file:com.hypersocket.certs.X509CertificateUtils.java

License:Open Source License

public static void saveCertificate(Certificate[] certs, OutputStream certfile) throws CertificateException {
    JcaPEMWriter writer = new JcaPEMWriter(new OutputStreamWriter(certfile));

    try {//w  w w  .jav a  2  s.co m
        for (Certificate c : certs) {
            writer.writeObject(c);
        }
        writer.flush();
        writer.close();
    } catch (IOException e) {
        throw new CertificateException("Failed to save certificate", e);
    }

}

From source file:com.hypersocket.certs.X509CertificateUtils.java

License:Open Source License

public static byte[] generatePKCS10(PrivateKey privateKey, PublicKey publicKey, String CN, String OU, String O,
        String L, String S, String C) throws Exception {

    JcaContentSignerBuilder csb = new JcaContentSignerBuilder("SHA1withRSA");
    ContentSigner cs = csb.build(privateKey);

    X500Principal principal = new X500Principal(
            "CN=" + CN + ", OU=" + OU + ", O=" + O + ", L=" + L + ", S=" + S + ", C=" + C);
    PKCS10CertificationRequestBuilder builder = new JcaPKCS10CertificationRequestBuilder(principal, publicKey);

    PKCS10CertificationRequest req = builder.build(cs);

    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    JcaPEMWriter p = null;
    try {//from   w w w .  j a v  a 2 s. c o  m
        p = new JcaPEMWriter(new OutputStreamWriter(bout));
        p.writeObject(req);
    } finally {
        if (p != null)
            p.close();
    }
    return bout.toByteArray();

}