Support detached signing and verifying

.gitignore

@@ -17,4 +17,4 @@ test/version_tmp
 tmp
 
 # Skip our compiled jruby-pgp.jar
-lib/pgp/jruby-pgp.jar
+# lib/pgp/jruby-pgp.jar

.rbenv-version

@@ -1 +1 @@
-jruby-1.7.2
+jruby-1.7.10

.ruby-gemset

@@ -0,0 +1 @@
+jruby-pgp

.ruby-version

@@ -0,0 +1 @@
+jruby-1.7.10

ext/org/sgonyea/pgp/Signer.java

@@ -10,124 +10,156 @@
 
 package org.sgonyea.pgp;
 
-import java.io.ByteArrayInputStream;
+import java.io.BufferedInputStream;
 import java.io.ByteArrayOutputStream;
-import java.io.File;
 import java.io.FileInputStream;
-import java.io.FileOutputStream;
-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 java.util.Date;
 import java.util.Iterator;
 
-import org.bouncycastle.bcpg.BCPGOutputStream;
 import org.bouncycastle.bcpg.ArmoredOutputStream;
-import org.bouncycastle.jce.provider.BouncyCastleProvider;
-import org.bouncycastle.openpgp.*;
+import org.bouncycastle.bcpg.BCPGOutputStream;
+import org.bouncycastle.openpgp.PGPCompressedData;
+import org.bouncycastle.openpgp.PGPCompressedDataGenerator;
+import org.bouncycastle.openpgp.PGPException;
+import org.bouncycastle.openpgp.PGPLiteralData;
+import org.bouncycastle.openpgp.PGPLiteralDataGenerator;
+import org.bouncycastle.openpgp.PGPPrivateKey;
+import org.bouncycastle.openpgp.PGPSecretKey;
+import org.bouncycastle.openpgp.PGPSecretKeyRing;
+import org.bouncycastle.openpgp.PGPSecretKeyRingCollection;
+import org.bouncycastle.openpgp.PGPSignature;
+import org.bouncycastle.openpgp.PGPSignatureGenerator;
+import org.bouncycastle.openpgp.PGPSignatureSubpacketGenerator;
+import org.bouncycastle.openpgp.PGPUtil;
 import org.bouncycastle.openpgp.operator.jcajce.JcaPGPContentSignerBuilder;
-import org.bouncycastle.openpgp.operator.jcajce.JcaPGPContentVerifierBuilderProvider;
 import org.bouncycastle.openpgp.operator.jcajce.JcePBESecretKeyDecryptorBuilder;
 
 public class Signer {
+	private String passphrase;
+	private PGPSecretKeyRingCollection _privateKeys;
+
+	public Signer() {
+	}
+
+	public Signer(PGPSecretKeyRingCollection privateKeys) {
+		setPrivateKeys(privateKeys);
+	}
+
+	/**
+	 * Accessor and Attribute Helper Methods
+	 **/
+	public PGPSecretKeyRingCollection getPrivateKeys() {
+		return _privateKeys;
+	}
+
+	public void setPrivateKeys(PGPSecretKeyRingCollection privateKeys) {
+		_privateKeys = privateKeys;
+	}
+
+	public void setPassphrase(String passphrase) {
+		this.passphrase = passphrase;
+	}
+
+	private PGPSecretKey findSecretKey() throws PGPException, NoSuchProviderException {
+		@SuppressWarnings("rawtypes")
+		Iterator keyRingIter = _privateKeys.getKeyRings();
+		while (keyRingIter.hasNext()) {
+			PGPSecretKeyRing keyRing = (PGPSecretKeyRing) keyRingIter.next();
+
+			@SuppressWarnings("rawtypes")
+			Iterator keyIter = keyRing.getSecretKeys();
+			while (keyIter.hasNext()) {
+				PGPSecretKey key = (PGPSecretKey) keyIter.next();
 
-  private PGPSecretKeyRingCollection _privateKeys;
+				if (key.isSigningKey()) {
+					return key;
+				}
+			}
+		}
 
-  private String passphrase;
+		throw new IllegalArgumentException("Can't find signing key in key ring.");
+	}
 
-  public Signer() { }
-  public Signer(PGPSecretKeyRingCollection privateKeys) {
-    setPrivateKeys(privateKeys);
-  }
+	public byte[] signData(byte[] inputData) throws Exception {
+		ByteArrayOutputStream signatureByteArrayOutputStream = new ByteArrayOutputStream();
+		ArmoredOutputStream armoredSignatureOutputStream = new ArmoredOutputStream(signatureByteArrayOutputStream);
 
-  /**
-   * Accessor and Attribute Helper Methods
-  **/
-  public PGPSecretKeyRingCollection getPrivateKeys() {
-    return _privateKeys;
-  }
+		PGPSecretKey pgpSigningKey = findSecretKey();
+		PGPPrivateKey pgpPrivateKey = pgpSigningKey.extractPrivateKey(new JcePBESecretKeyDecryptorBuilder()
+				.setProvider("BC").build(passphrase.toCharArray()));
+		PGPSignatureGenerator signatureGenerator = new PGPSignatureGenerator(new JcaPGPContentSignerBuilder(
+				pgpSigningKey.getPublicKey().getAlgorithm(), PGPUtil.SHA1).setProvider("BC"));
 
-  public void setPrivateKeys(PGPSecretKeyRingCollection privateKeys) {
-    _privateKeys = privateKeys;
-  }
+		signatureGenerator.init(PGPSignature.BINARY_DOCUMENT, pgpPrivateKey);
 
-  public void setPassphrase(String passphrase) {
-    this.passphrase = passphrase;
-  }
+		@SuppressWarnings("rawtypes")
+		Iterator iter = pgpSigningKey.getPublicKey().getUserIDs();
+		if (iter.hasNext()) {
+			PGPSignatureSubpacketGenerator subpacketGenerator = new PGPSignatureSubpacketGenerator();
 
-  private PGPSecretKey findSecretKey()
-    throws PGPException, NoSuchProviderException {
-    Iterator keyRingIter = _privateKeys.getKeyRings();
-    while (keyRingIter.hasNext())
-    {
-        PGPSecretKeyRing keyRing = (PGPSecretKeyRing)keyRingIter.next();
+			subpacketGenerator.setSignerUserID(false, (String) iter.next());
+			signatureGenerator.setHashedSubpackets(subpacketGenerator.generate());
+		}
 
-        Iterator keyIter = keyRing.getSecretKeys();
-        while (keyIter.hasNext())
-        {
-            PGPSecretKey key = (PGPSecretKey)keyIter.next();
+		PGPCompressedDataGenerator compressor = new PGPCompressedDataGenerator(PGPCompressedData.ZLIB);
 
-            if (key.isSigningKey())
-            {
-                return key;
-            }
-        }
-    }
+		BCPGOutputStream pgpOutputStream = new BCPGOutputStream(compressor.open(armoredSignatureOutputStream));
 
-    throw new IllegalArgumentException("Can't find signing key in key ring.");
-  }
+		signatureGenerator.generateOnePassVersion(false).encode(pgpOutputStream);
 
-  public byte[] signData(byte[] clearData)
-    throws Exception {
-      String fileName = "something.txt";
-      ByteArrayOutputStream bos = new ByteArrayOutputStream();
-      ArmoredOutputStream out = new ArmoredOutputStream(bos);
+		PGPLiteralDataGenerator literalDataGenerator = new PGPLiteralDataGenerator();
+		OutputStream literalDataGeneratorOutputStream = literalDataGenerator.open(pgpOutputStream,
+				PGPLiteralData.BINARY, PGPLiteralDataGenerator.CONSOLE, inputData.length, PGPLiteralDataGenerator.NOW);
 
-      PGPSecretKey                pgpSec = findSecretKey();
-      PGPPrivateKey               pgpPrivKey = pgpSec.extractPrivateKey(new JcePBESecretKeyDecryptorBuilder().setProvider("BC").build(passphrase.toCharArray()));
-      PGPSignatureGenerator       sGen = new PGPSignatureGenerator(new JcaPGPContentSignerBuilder(pgpSec.getPublicKey().getAlgorithm(), PGPUtil.SHA1).setProvider("BC"));
+		literalDataGeneratorOutputStream.write(inputData);
+		signatureGenerator.update(inputData);
 
-      sGen.init(PGPSignature.BINARY_DOCUMENT, pgpPrivKey);
+		literalDataGenerator.close();
 
-      Iterator    it = pgpSec.getPublicKey().getUserIDs();
-      if (it.hasNext())
-      {
-          PGPSignatureSubpacketGenerator  spGen = new PGPSignatureSubpacketGenerator();
+		signatureGenerator.generate().encode(pgpOutputStream);
 
-          spGen.setSignerUserID(false, (String)it.next());
-          sGen.setHashedSubpackets(spGen.generate());
-      }
+		compressor.close();
 
-      PGPCompressedDataGenerator  cGen = new PGPCompressedDataGenerator(
-                                                              PGPCompressedData.ZLIB);
+		armoredSignatureOutputStream.close();
 
-      BCPGOutputStream            bOut = new BCPGOutputStream(cGen.open(out));
+		return signatureByteArrayOutputStream.toByteArray();
+	}
 
-      sGen.generateOnePassVersion(false).encode(bOut);
+	public String signDataDetached(String inputFileName) throws Exception {
+		ByteArrayOutputStream signatureByteArrayOutputStream = new ByteArrayOutputStream();
+		ArmoredOutputStream armoredSignatureOutputStream = new ArmoredOutputStream(signatureByteArrayOutputStream);
 
-      File                        file = new File(fileName);
-      PGPLiteralDataGenerator     lGen = new PGPLiteralDataGenerator();
-      OutputStream                lOut = lGen.open(bOut,
-        PGPLiteralData.BINARY, PGPLiteralDataGenerator.CONSOLE,
-        clearData.length, PGPLiteralDataGenerator.NOW);
-      int                         ch;
+		PGPSecretKey pgpSigningKey = findSecretKey();
+		PGPPrivateKey pgpPrivateKey = pgpSigningKey.extractPrivateKey(new JcePBESecretKeyDecryptorBuilder()
+				.setProvider("BC").build(passphrase.toCharArray()));
+		PGPSignatureGenerator signatureGenerator = new PGPSignatureGenerator(new JcaPGPContentSignerBuilder(
+				pgpSigningKey.getPublicKey().getAlgorithm(), PGPUtil.SHA1).setProvider("BC"));
 
-      lOut.write(clearData);
-      sGen.update(clearData);
+		signatureGenerator.init(PGPSignature.BINARY_DOCUMENT, pgpPrivateKey);
 
-      lGen.close();
+		BCPGOutputStream pgpOutputStream = new BCPGOutputStream(armoredSignatureOutputStream);
 
-      sGen.generate().encode(bOut);
+		InputStream inputFileInputStream = new BufferedInputStream(new FileInputStream(inputFileName));
 
-      cGen.close();
+		int ch;
+		while ((ch = inputFileInputStream.read()) >= 0) {
+			signatureGenerator.update((byte) ch);
+		}
 
-      out.close();
+		signatureGenerator.generate().encode(pgpOutputStream);
 
-      return bos.toByteArray();
-  }
+		inputFileInputStream.close();
 
+		armoredSignatureOutputStream.close();
 
+		String signatureString = new String(signatureByteArrayOutputStream.toByteArray());
+
+		signatureByteArrayOutputStream.close();
+
+		pgpOutputStream.close();
+
+		return signatureString;
+	}
 }