PGP Encryption using Bouncy Castle

http://cephas.net/blog/2004/04/01/pgp-encryption-using-bouncy-castle/

import java.io.BufferedReader;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.security.NoSuchProviderException;

import java.security.SecureRandom;

import java.security.Security;

import org.bouncycastle.bcpg.ArmoredOutputStream;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import org.bouncycastle.openpgp.PGPCompressedDataGenerator;

import org.bouncycastle.openpgp.PGPEncryptedDataGenerator;

import org.bouncycastle.openpgp.PGPException;

import org.bouncycastle.openpgp.PGPLiteralData;

import org.bouncycastle.openpgp.PGPPublicKey;

import org.bouncycastle.openpgp.PGPPublicKeyRing;

import org.bouncycastle.openpgp.PGPUtil;

public class BouncyCastlePGPTest {

 public static void main(String[] args) {

  // the keyring that holds the public key we're encrypting with

  String publicKeyFilePath = "C:\\pgp6.5.8\\pubring.pkr";

  // init the security provider

  Security.addProvider(new BouncyCastleProvider());

  try {

   System.out.println("Creating a temp file...");

   // create a file and write the string to it

   File outputfile = File.createTempFile("pgp", null);

   FileWriter writer = new FileWriter(outputfile);

   writer.write("the message I want to encrypt".toCharArray());

   writer.close();

   System.out.println("Temp file created at ");

   System.out.println(outputfile.getAbsolutePath());

   System.out.println("Reading the temp file to make sure that the bits were written\n----------------------------");

   BufferedReader isr = new BufferedReader(new FileReader(outputfile));

   String line = "";

   while ((line = isr.readLine()) != null) {

    System.out.println(line + "\n");

   }

   // read the key

   FileInputStream in = new FileInputStream(publicKeyFilePath);

   PGPPublicKey key = readPublicKey(in);

   // find out a little about the keys in the public key ring

   System.out.println("Key Strength = " + key.getBitStrength());

   System.out.println("Algorithm = " + key.getAlgorithm());

   int count = 0;

   for (java.util.Iterator iterator = key.getUserIDs(); iterator.hasNext();) {

    count++;

    System.out.println((String)iterator.next()); 

   }

   System.out.println("Key Count = " + count);

   // create an armored ascii file

   FileOutputStream out = new FileOutputStream(outputfile.getAbsolutePath() + ".asc");

   // encrypt the file

   encryptFile(outputfile.getAbsolutePath(), out, key);

   System.out.println("Reading the encrypted file\n----------------------------");

   BufferedReader isr2 = new BufferedReader(new FileReader(new File(outputfile.getAbsolutePath() + ".asc")));

   String line2 = "";

   while ((line2 = isr2.readLine()) != null) {

    System.out.println(line2);

   }

  } catch (PGPException e) {

   System.out.println(e.toString());

   System.out.println(e.getUnderlyingException().toString());

  } catch (Exception e) {

   System.out.println(e.toString());

  }

 }

 private static PGPPublicKey readPublicKey(InputStream in) throws IOException {

  try {

   PGPPublicKeyRing pgpPub = new PGPPublicKeyRing(in);

   return pgpPub.getPublicKey();

  } catch (IOException io) {

   System.out.println("readPublicKey() threw an IOException");

   System.out.println(io.toString());

   throw io;

  }

 }

 private static void encryptFile(String fileName, OutputStream out, PGPPublicKey encKey)

 throws IOException, NoSuchProviderException, PGPException 

 {

  out = new ArmoredOutputStream(out);

  ByteArrayOutputStream bOut = new ByteArrayOutputStream();

  System.out.println("creating comData...");

  // get the data from the original file

  PGPCompressedDataGenerator comData = new PGPCompressedDataGenerator(PGPCompressedDataGenerator.ZIP);

  PGPUtil.writeFileToLiteralData(comData.open(bOut), PGPLiteralData.BINARY, new File(fileName));

  comData.close();

  System.out.println("comData created...");

  System.out.println("using PGPEncryptedDataGenerator...");

  // object that encrypts the data

  PGPEncryptedDataGenerator cPk = new PGPEncryptedDataGenerator(PGPEncryptedDataGenerator.CAST5, new SecureRandom(), "BC");

  cPk.addMethod(encKey);

  System.out.println("used PGPEncryptedDataGenerator...");

  // take the outputstream of the original file and turn it into a byte array

  byte[] bytes = bOut.toByteArray();

  System.out.println("wrote bOut to byte array...");

  // write the plain text bytes to the armored outputstream

  OutputStream cOut = cPk.open(out, bytes.length);

  cOut.write(bytes);

  // cOut.close();

  cPk.close();

  out.close();

 }

}