jruby-pgp 0.0.1

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# Skip our compiled jruby-pgp.jar
+lib/pgp/jruby-pgp.jar

data/.rspec

@@ -0,0 +1 @@
+--color --format documentation

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in jruby-pgp.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Scott Gonyea
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+# PGP
+
+This is a Java + JRuby wrapper around the Bouncy Castle PGP APIs.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'jruby-pgp'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jruby-pgp
+
+## Usage
+
+This gem currently features everything I need and nothing I don't. Pull requests are very much welcome;
+feature requests will be considered.
+
+The general goal is to provide fast, non-terrible wrappers around the Bouncy Castle PGP APIs. Bare-metal
+JRuby code will then plug into those wrappers, to minimize memory bloat. Directly hooking JRuby into the
+BC PGP APIs is certainly possible, but they are a poorly designed pile of rocks. Using these APIs from
+JRuby can yield some unwanted bloat, especially when you're resource constrained:
+
+[Example using BC PGP directly from JRuby](https://gist.github.com/1954648)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,21 @@
+require 'bundler/gem_tasks'
+require 'rake/javaextensiontask'
+
+require 'rspec/core/rake_task'
+
+Rake::JavaExtensionTask.new('jruby-pgp') do |ext|
+  jruby_home = RbConfig::CONFIG['prefix']
+  jars = ["#{jruby_home}/lib/jruby.jar"] + FileList['lib/pgp/jars/*.jar']
+
+  ext.ext_dir   = 'ext'
+  ext.lib_dir   = 'lib/pgp'
+  ext.classpath = jars.map { |x| File.expand_path x }.join ':'
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |task|
+    task.rcov = true
+end
+
+task :default => %w(compile spec)
+
+task :build => :compile

data/ext/org/sgonyea/pgp/Encryptor.java

@@ -0,0 +1,293 @@
+/**
+ * Much of this code was stolen from this Stack Overflow post:
+ *  http://stackoverflow.com/questions/3939447/how-to-encrypt-a-string-stream-with-bouncycastle-pgp-without-starting-with-a-fil
+ *
+ * In addition to the java versions of this lump of code, that have been floating around on the internet:
+ *  https://gist.github.com/1954648
+ *
+ * Thanks to everyone who has posted on the topic of Bouncy Castle's PGP Library.
+ */
+
+package org.sgonyea.pgp;
+
+import java.io.ByteArrayInputStream;
+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 java.util.List;
+import java.util.ArrayList;
+
+import org.bouncycastle.bcpg.ArmoredOutputStream;
+import org.bouncycastle.bcpg.CompressionAlgorithmTags;
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
+import org.bouncycastle.openpgp.PGPCompressedData;
+import org.bouncycastle.openpgp.PGPCompressedDataGenerator;
+import org.bouncycastle.openpgp.PGPEncryptedData;
+import org.bouncycastle.openpgp.PGPEncryptedDataGenerator;
+import org.bouncycastle.openpgp.PGPEncryptedDataList;
+import org.bouncycastle.openpgp.PGPException;
+import org.bouncycastle.openpgp.PGPLiteralData;
+import org.bouncycastle.openpgp.PGPLiteralDataGenerator;
+import org.bouncycastle.openpgp.PGPObjectFactory;
+import org.bouncycastle.openpgp.PGPPrivateKey;
+import org.bouncycastle.openpgp.PGPPublicKey;
+import org.bouncycastle.openpgp.PGPPublicKeyEncryptedData;
+import org.bouncycastle.openpgp.PGPPublicKeyRing;
+import org.bouncycastle.openpgp.PGPPublicKeyRingCollection;
+import org.bouncycastle.openpgp.PGPSecretKey;
+import org.bouncycastle.openpgp.PGPSecretKeyRingCollection;
+import org.bouncycastle.openpgp.PGPUtil;
+import org.bouncycastle.openpgp.operator.bc.BcPGPDataEncryptorBuilder;
+import org.bouncycastle.openpgp.operator.bc.BcPublicKeyKeyEncryptionMethodGenerator;
+
+public class Encryptor {
+  private List<PGPPublicKey> _publicKeys;
+  private List<BcPublicKeyKeyEncryptionMethodGenerator> _publicKeyEMGs;
+  private boolean _integrityCheck;
+  private boolean _asciiArmor;
+  private char    _format;
+  private int     _compression;
+  private int     _algorithm;
+
+  private void init() {
+    _publicKeys     = new ArrayList<PGPPublicKey>();
+    _publicKeyEMGs  = new ArrayList<BcPublicKeyKeyEncryptionMethodGenerator>();
+    _integrityCheck = true;
+    _asciiArmor     = true;
+
+    useBinaryFormat();
+    useZIPCompression();
+
+    _algorithm = PGPEncryptedData.CAST5;
+  }
+
+  public Encryptor() {
+    init();
+  }
+
+  public Encryptor(PGPPublicKey publicKey) {
+    init();
+    addPublicKey(publicKey);
+  }
+
+  public Encryptor(List<PGPPublicKey> publicKeys) {
+    init();
+    addPublicKeys(publicKeys);
+  }
+
+
+  /**
+   * Accessor and Attribute Helper Methods
+   */
+
+  /* integrityCheck */
+  public void setIntegrityCheck(boolean integrityCheck) {
+    _integrityCheck = integrityCheck;
+  }
+
+  public boolean getIntegrityCheck() {
+    return _integrityCheck;
+  }
+
+  /* asciiArmor */
+  public void setAsciiArmor(boolean asciiArmor) {
+    _asciiArmor = asciiArmor;
+  }
+
+  public boolean getAsciiArmor() {
+    return _asciiArmor;
+  }
+
+  /* publicKeys */
+  public void setPublicKeys(List<PGPPublicKey> publicKeys) {
+    _publicKeys = publicKeys;
+
+    clearPublicKeyEMGs();
+    addToPublicKeyEMG(publicKeys);
+  }
+
+  public List<PGPPublicKey> getPublicKeys() {
+    return _publicKeys;
+  }
+
+  public void addPublicKey(PGPPublicKey publicKey) {
+    _publicKeys.add(publicKey);
+    addToPublicKeyEMG(publicKey);
+  }
+
+  public void addPublicKeys(List<PGPPublicKey> publicKeys) {
+    _publicKeys.addAll(publicKeys);
+
+    addToPublicKeyEMG(publicKeys);
+  }
+
+  /* publicKeyEMGs */
+  public List<BcPublicKeyKeyEncryptionMethodGenerator> getPublicKeyEMGs() {
+    return _publicKeyEMGs;
+  }
+
+  public void clearPublicKeyEMGs() {
+    _publicKeyEMGs = new ArrayList<BcPublicKeyKeyEncryptionMethodGenerator>();
+  }
+
+  public void addToPublicKeyEMG(PGPPublicKey publicKey) {
+    _publicKeyEMGs.add(new BcPublicKeyKeyEncryptionMethodGenerator(publicKey));
+  }
+
+  public void addToPublicKeyEMG(List<PGPPublicKey> publicKeys) {
+    for(PGPPublicKey publicKey : publicKeys) {
+      addToPublicKeyEMG(publicKey);
+    }
+  }
+
+  /* format */
+  public char getFormat() {
+    return _format;
+  }
+
+  public void setFormat(char format) {
+    switch(format) {
+      case PGPLiteralData.BINARY:
+      case PGPLiteralData.TEXT:
+      case PGPLiteralData.UTF8:   _format = format; break;
+      default:
+        throw new IllegalArgumentException("Invalid format. Acceptable formats: 'b', 't', or 'u' (respectively: binary, text, or utf8)");
+    }
+  }
+  public void useBinaryFormat() { setFormat(PGPLiteralData.BINARY); }
+  public void useTextFormat()   { setFormat(PGPLiteralData.TEXT);   }
+  public void useUTF8Format()   { setFormat(PGPLiteralData.UTF8);   }
+
+  /* compression */
+  public int getCompression() {
+    return _compression;
+  }
+
+  public void setCompression(int compression) {
+    _compression = compression;
+  }
+  public void useNoCompression()    { setCompression(CompressionAlgorithmTags.UNCOMPRESSED); }
+  public void useZIPCompression()   { setCompression(CompressionAlgorithmTags.ZIP);   }
+  public void useZLIBCompression()  { setCompression(CompressionAlgorithmTags.ZLIB);  }
+  public void useBZIP2Compression() { setCompression(CompressionAlgorithmTags.BZIP2); }
+
+  /* algorithm */
+  public int getAlgorithm() {
+    return _algorithm;
+  }
+
+  /**
+   * @see org.bouncycastle.bcpg.SymmetricKeyAlgorithmTags
+   */
+  public void setAlgorithm(int algorithm) {
+    _algorithm = algorithm;
+  }
+
+  /** End Accessor Methods **/
+
+
+  /**
+   * Encryption Class / Static Methods
+   */
+
+  /**
+   * This method preserves the much of the original API, so that you can just call the class method should you need to.
+   */
+  public static byte[] encrypt(byte[] clearData, List<PGPPublicKey> publicKeys, String fileName, boolean withIntegrityCheck, boolean armor)
+    throws IOException, PGPException, NoSuchProviderException {
+      Encryptor encryptor = new Encryptor(publicKeys);
+
+      return encryptor.encrypt(clearData, fileName);
+  }
+
+
+  /**
+   * Encryption Instance Methods
+   */
+  public byte[] encrypt(byte[] clearData, String fileName)
+    throws IOException, PGPException, NoSuchProviderException {
+      return encrypt(clearData, fileName, new Date());
+  }
+
+  /**
+   * Allows you to override the modificationTime. This method was split off
+   *  for mock-free testing of encrypted output.
+   */
+  public byte[] encrypt(byte[] clearData, String fileName, Date modificationTime)
+    throws IOException, PGPException, NoSuchProviderException {
+      if (fileName == null)
+        fileName = PGPLiteralData.CONSOLE;
+
+      PGPEncryptedDataGenerator   pgpDataGenerator        = newPGPDataGenerator();
+      PGPLiteralDataGenerator     dataGenerator           = new PGPLiteralDataGenerator();
+      PGPCompressedDataGenerator  compressedDataGenerator = new PGPCompressedDataGenerator(getCompression());
+
+      ByteArrayOutputStream   compressedOutput  = new ByteArrayOutputStream();
+      ByteArrayOutputStream   encryptedOutput   = new ByteArrayOutputStream();
+
+      OutputStream  compressedDataStream  = compressedDataGenerator.open(compressedOutput); // open it with the final
+      OutputStream  output                = encryptedOutput;
+      OutputStream  compressorStream;
+      OutputStream  encryptorStream;
+
+      byte[] compressedBytes;
+
+      // Step 1: Compress the data
+      compressorStream = dataGenerator.open(
+        compressedDataStream, // the compressed output stream
+        getFormat(),
+        fileName,             // "filename" to store
+        clearData.length,     // length of clear data
+        modificationTime      // current time
+      );
+      compressorStream.write(clearData);
+
+      dataGenerator.close();
+      compressedDataGenerator.close();
+
+      compressedBytes = compressedOutput.toByteArray();
+
+
+      // Step 2: ASCII Armor the data if desired
+      output = encryptedOutput;
+      if (getAsciiArmor())
+        output = new ArmoredOutputStream(output);
+
+
+      // Step 3: Encrypt the data
+      encryptorStream = pgpDataGenerator.open(output, compressedBytes.length);
+      encryptorStream.write(compressedBytes);
+      encryptorStream.close();
+
+      output.close();
+
+      // Return the data as a byte array
+      return encryptedOutput.toByteArray();
+  }
+
+  public PGPEncryptedDataGenerator newPGPDataGenerator() {
+    PGPEncryptedDataGenerator generator;
+    BcPGPDataEncryptorBuilder builder;
+
+    builder = new BcPGPDataEncryptorBuilder(getAlgorithm());
+    builder.setWithIntegrityPacket(getIntegrityCheck());
+
+    generator = new PGPEncryptedDataGenerator(builder);
+
+    // Add all our public keys to the Data Generator
+    for(BcPublicKeyKeyEncryptionMethodGenerator fml : getPublicKeyEMGs()) {
+      generator.addMethod(fml);
+    }
+
+    return generator;
+  }
+}

data/ext/org/sgonyea/pgp/PGP.java

@@ -0,0 +1,49 @@
+/**
+ * Much of this code was stolen from this Stack Overflow post:
+ *  http://stackoverflow.com/questions/3939447/how-to-encrypt-a-string-stream-with-bouncycastle-pgp-without-starting-with-a-fil
+ *
+ * In addition to the java versions of this lump of code, that have been floating around on the internet:
+ *  https://gist.github.com/1954648
+ *
+ * Thanks to everyone who has posted on the topic of Bouncy Castle's PGP Library.
+ */
+
+package org.sgonyea.pgp;
+
+import java.io.ByteArrayInputStream;
+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.ArmoredOutputStream;
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
+import org.bouncycastle.openpgp.PGPCompressedData;
+import org.bouncycastle.openpgp.PGPCompressedDataGenerator;
+import org.bouncycastle.openpgp.PGPEncryptedData;
+import org.bouncycastle.openpgp.PGPEncryptedDataGenerator;
+import org.bouncycastle.openpgp.PGPEncryptedDataList;
+import org.bouncycastle.openpgp.PGPException;
+import org.bouncycastle.openpgp.PGPLiteralData;
+import org.bouncycastle.openpgp.PGPLiteralDataGenerator;
+import org.bouncycastle.openpgp.PGPObjectFactory;
+import org.bouncycastle.openpgp.PGPPrivateKey;
+import org.bouncycastle.openpgp.PGPPublicKey;
+import org.bouncycastle.openpgp.PGPPublicKeyEncryptedData;
+import org.bouncycastle.openpgp.PGPPublicKeyRing;
+import org.bouncycastle.openpgp.PGPPublicKeyRingCollection;
+import org.bouncycastle.openpgp.PGPSecretKey;
+import org.bouncycastle.openpgp.PGPSecretKeyRingCollection;
+import org.bouncycastle.openpgp.PGPUtil;
+
+public class PGP {
+
+}

data/jruby-pgp.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'pgp/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'jruby-pgp'
+  gem.version       = PGP::VERSION
+  gem.authors       = ['Scott Gonyea']
+  gem.email         = ['me@sgonyea.com']
+  gem.description   = %q{PGP for JRuby}
+  gem.summary       = %q{This is a Java+JRuby wrapper around the Bouncy Castle PGP APIs}
+  gem.homepage      = 'https://github.com/sgonyea/jruby-pgp'
+
+  gem.files         = `git ls-files`.split($/) + %w[lib/pgp/jruby-pgp.jar]
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rake-compiler'
+end

data/lib/jruby-pgp.rb

@@ -0,0 +1 @@
+require 'pgp'

data/lib/pgp.rb

@@ -0,0 +1,24 @@
+require 'java'
+require 'pgp/jars/bcprov-jdk15on-147.jar'
+require 'pgp/jars/bcpg-jdk15on-147.jar'
+require 'pgp/jruby-pgp.jar'
+
+require 'pgp/decryptor'
+require 'pgp/encryptor'
+require 'pgp/private_key'
+
+module PGP
+  autoload :VERSION, 'pgp/version'
+
+  BC_Provider_Code = "BC"
+
+  java_import 'java.io.ByteArrayInputStream'
+  java_import 'java.security.Security'
+  java_import 'org.bouncycastle.jce.provider.BouncyCastleProvider'
+
+  Security.add_provider BouncyCastleProvider.new
+
+  def self.string_to_bais(string)
+    ByteArrayInputStream.new string.to_java_bytes
+  end
+end

data/lib/pgp/decryptor.rb

@@ -0,0 +1,58 @@
+module PGP
+  class Decryptor
+    include_package "org.bouncycastle.openpgp"
+
+    java_import 'java.io.ByteArrayOutputStream'
+
+    def self.decrypt(encrypted_text, private_key_file)
+      bytes = PGP.string_to_bais(encrypted_text)
+      dec_s = PGPUtil.get_decoder_stream(bytes)
+      pgp_f = PGPObjectFactory.new(dec_s)
+
+      enc_data = pgp_f.next_object
+      enc_data = pgp_f.next_object unless PGPEncryptedDataList === enc_data
+
+      data_enumerator = enc_data.get_encrypted_data_objects
+
+      sec_key = nil
+      pbe     = nil
+
+      data_enumerator.each do |pubkey_enc_data|
+        pbe     = pubkey_enc_data
+        key_id  = pubkey_enc_data.get_key_id
+        sec_key = PrivateKey.from_file(private_key_file, key_id)
+
+        if sec_key.nil?
+          # @todo: Should we notify Airbrake?
+          Ace.logger.debug "This may be cause for concern. The data being decrypted has a key_id of '#{key_id}', which can not be found in the private key file '#{CE_Private_Key}'."
+        else
+          break
+        end
+      end
+
+      clear = pbe.get_data_stream(sec_key, BC_Provider_Code)
+
+      plain_fact = PGPObjectFactory.new(clear)
+
+      message = plain_fact.next_object
+
+      if(PGPCompressedData === message)
+        pgp_fact  = PGPObjectFactory.new(message.get_data_stream)
+        message   = pgp_fact.next_object
+      end
+
+      baos = ByteArrayOutputStream.new
+
+      if(PGPLiteralData === message)
+        unc = message.get_input_stream
+        while((ch = unc.read) >= 0)
+          baos.write(ch)
+        end
+      end
+
+      baos.to_string
+    end
+
+
+  end
+end

data/lib/pgp/encryptor.rb

@@ -0,0 +1,28 @@
+module PGP
+  class Encryptor < org.sgonyea.pgp.Encryptor
+    include_package "org.bouncycastle.openpgp"
+
+    def add_keys_from_file(filename)
+      key_enumerator = keyring_from_file(filename).get_key_rings
+
+      key_enumerator.each do |pk_ring|
+        pk_enumerator = pk_ring.get_public_keys
+
+        pk_enumerator.each do |key|
+          next unless key.is_encryption_key
+
+          add_public_key key
+        end
+      end
+    end
+
+    protected
+    def keyring_from_file(filename)
+      file = File.open(filename)
+      yafs = PGPUtil.get_decoder_stream(file.to_inputstream)
+
+      PGPPublicKeyRingCollection.new(yafs)
+    end
+
+  end
+end

data/lib/pgp/private_key.rb

@@ -0,0 +1,34 @@
+module PGP
+  # This is more module than class. Eventually it will probably inherit from
+  #   the PGPPrivateKey class and make using it less ghoulish.
+  class PrivateKey
+    include_package "org.bouncycastle.openpgp"
+
+    def self.from_string(string, key_id)
+      stream = PGP.string_to_bais(string)
+      pgp_sec = keyring_from_stream(stream)
+      sec_key = pgp_sec.get_secret_key(key_id)
+
+      sec_key.extract_private_key(nil, BC_Provider_Code) if sec_key
+    end
+
+    def self.from_file(filename, key_id)
+      pgp_sec = keyring_from_file(filename)
+      sec_key = pgp_sec.get_secret_key(key_id)
+
+      sec_key.extract_private_key(nil, BC_Provider_Code) if sec_key
+    end
+
+    protected
+    def self.keyring_from_file(filename)
+      file = File.open(filename)
+      keyring_from_stream(file.to_inputstream)
+    end
+
+    def self.keyring_from_stream(stream)
+      yafs = PGPUtil.get_decoder_stream(stream)
+      PGPSecretKeyRingCollection.new(yafs)
+    end
+
+  end
+end

data/lib/pgp/version.rb

@@ -0,0 +1,3 @@
+module PGP
+  VERSION = '0.0.1'
+end

data/spec/lib/pgp/encryptor_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe PGP::Encryptor do
+  let(:private_key_path)  { Fixtures_Path.join('private_key.asc').to_s }
+  let(:public_key_path)   { Fixtures_Path.join('public_key.asc').to_s }
+
+  describe '#encrypt' do
+    let(:string) { "FooBar" }
+    let(:encryptor) { PGP::Encryptor.new }
+
+    before {
+      encryptor.add_keys_from_file(public_key_path)
+    }
+
+    it "it's encrypted string should be decryptable. durr" do
+      encrypted_string = encryptor.encrypt(string.to_java_bytes, "some filename")
+
+      PGP::Decryptor.decrypt(String.from_java_bytes(encrypted_string), private_key_path).should == string
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require 'bundler/setup'
+
+Bundler.require :development, :test
+
+require 'jruby-pgp'
+
+Fixtures_Path = Bundler.root + 'spec/support/fixtures/'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/support/fixtures/private_key.asc

@@ -0,0 +1,63 @@
+-----BEGIN PGP PRIVATE KEY BLOCK-----
+Version: GnuPG/MacGPG2 v2.0.17 (Darwin)
+
+lQOYBE/aR0UBCADE72vjhccW1OZFT5qjja5Oh/qJodkuaEbcZjy2FUOel8zgnIRM
+dop+Yvs0mWIBKDTnPO+v4cm4W/9TUSpB8wHOMuNi1Qwr4tNbUzSIMbQGENSM/w7f
+G3nBLzFBlpKk1ho24Kv3RuF50aWg2fw5stmE8htJhK1JS997vKase/ZC51my0DJH
+Y+DIkXH+7AJz+zyaypHbJ9aiqGGjPRXsymdHFvoT6Xjii0zl0xKdSJgt06IGr7N3
+h8Rm8HJG9MNsHEBwpH2KW9QY5g4oNZzYg/VssUjFCFIKrkChlssQh0suSsIYrIDn
+OMKYmrVgUAznLEYR6Jrw0x7scW5RfEVTvBvvABEBAAEAB/4sMBCEN7MpQ1H7wVXQ
+Vu0Cf+5OTXt+tzUXJPWAYZsPjb4Rs+zXf02p+CmnbrcXzV65d+nMDByH+lR67F5P
+9+eyzaZJucYGXtnPxwalfImJRuN6U4yRsQeLujwSHGgBBm1RXO4ZCNV00P6Z7e9z
+PtchxnUq9NMw/A5EJFs9nn7uGbfn85MvtW6/k1h6WRFisBx7BkcAt+25UD9FEPgh
+8/u0TC6h9h9PXTrrNCqSYweWuMhjwZg1t+QSglJsrEST9ONBwT8KA80ll4NOJTTW
+ExFJTlGvWDsrpORmVpgn7sgT7picO+97X4h+al10u/3mVNICQzFHTsNXtAIfYYkS
+/hjxBADPQ14MLaKK+1MZEQLGigHcPq7m49N0bhTJwfY2P75Eyp6ec4vNy3b6KXF7
+R0JgJCi0PkqyMsmMZd0BfJWbnKS++xk1L6pCFAg1i0EnThdNQH8u9SXs8qR9gcPj
+6k1giI+/0xRtPMWiNtrPHRjWb8wMnKsBJAkJChd6gjGJvJjtFwQA8z5YEVOhJ8Ex
+4a7GwFlL24bDsw+4jCyjdc4Wggi4roUJkWaFGFdB01Q0OiLC99rdnz2/yzDKX7mE
+lUergdiZNLV6jl5weaO2bxFpmtxe2GOiCohjCezGi4z2E/frVPyf7amZeXfyILan
+7fAvJC5idtu07ixChwACobOv5/3dfukEANJHYDhunATdkbwewTQ0oca06HZzwZDF
+yFiILOKvWcg8lMp35tUmM2fZn25kD8Vxlb12ZveTB8jb0E32umIRlzo9UlHQWzKi
+84rOrX5fZwiEcOA0WB/2OP6AQjlhcD3P8Zg88/6WoR7QABwRcqO3IHUY79EyDekc
+eT/hUhqgKNqSPK60HkpSdWJ5IEJHIFBHUCBCdWcgPGZvb0BiYXIuY29tPokBOAQT
+AQIAIgUCT9pHRQIbLwYLCQgHAwIGFQgCCQoLBBYCAwECHgECF4AACgkQSFCNMR3T
+QTGm1ggAqmGGzV/b75BM9o/419jbz4ULP+JIsNe4R+bEP4c1zP6/8Y4av17bBAYu
+lB3Q3hjmfjlbfI3ahE69in6y2V4gEOnLGzRIutNpHPXTd3UeovpNYNgIkxahqXTv
+uZgRKpXA6Dsii9/s6NvNfWhbfyw1ioYuK84qFRhhMOHt243p9Few8wdmCtXna1aK
+UQCoa8ibkWkOae1btp+C27CijFxPnALl7sojZYsMf8GLp/RSvlVGSYw4BScHGXhV
+KrW9VFsa3LMUGBaECPEIpRYkJsIXnSLHg+V37YKBnYtMFwmUAurrGpApCCby2+kC
+QyRP6AXJXpscLnLQuto1aULz/W+w6Z0DmARP2kdFAQgA0hx9wNndIf+1UuEOKO1K
+hRVJ+eJqfKfgET4k34BI+7k0WWFWaNb0tL0r4M9qHAMoB9ZzwLA8Ql1I4uqO1xKe
+a983KpsuHRD3w0BW0Ku1nrYvezWBiUK7/YKQJd9tJVuJMmirl0hZGWVJHR/LW8N0
+Ik/wdCmA1myTG+E1K/YOYOZ0k3YqMvTWF3c7IWDz16vT5ebyho/R40dbb2DTLR5c
+yOO+SlGIPCLsXUuN1HvEo2qoOcYWVRbRJ2TwW3237/AwkS+LlCtVFaGcJNKpHNgC
+Ee5Nxj1BBWsDXzq5vEPy/BFnQJPGBBtQDWP2yBOTENtqVvgIA7LSdEspDVikBtn3
+bQARAQABAAf+IlYRnvB7mNDG+xJYVAvjP7ho7HM538E3dtnnALdgNfLgQTMNAfkO
+6HJ5tzVuK8HASvea1wR19Ip2HM8kJLWgOhSyWT4e3RUmyDu9dEB7X8J6I/Jshtfn
+DNjHYckPdylsVFaSpBhopyPMPPwzKX3Zfrn9m54kteXsbIPzQonlc6QpjMJNooNg
+sxZLdh+7PmfVHPmx1fLV43z1SWCEyxWk0VrXWO/cs4So91qUsp/M8mGtbFnpulZs
+DC9HUOLWM6JwK4w7mpeiiefA2T1EpMSqYWbTo2LUgW++xjlKomr29X4ciBpvyNPa
+EX9M3UpwpnhuPACbaDupmMbjGmkMG6wtaQQA03r2H6oY3q7oaAKeNwVpjDT8NSxV
+4UK/CP3UEt2s4deQh3MsPTgQW4wrqQA1+7wurKXj+6JoY7DswpV2ymOCi16E7BBi
+CDCoqKrN3kGrtnNysacjpYKbVigMC/X9IKw91gl1bilX5zOdexZzKpSJDVjtgwBX
+4qDY9emf64+ctuMEAP5XwC/mMyKdHtm1FNXSCr3Ah7boPcSvkjMG8pLPBsex5RnH
+oLA8TrGcgFEg2HaTzFxiOpdGHF8ngqkDT3iatPno/PcHCArWevb9k9SDFV5z9GPl
+lBam/oVxHxLXyHxYmNx03Ec8V/fy767hNcE9PXSM3VtzJbuoyrDu8LyPU5lvA/9D
+FOcdzxETstY1l5FrD0bypC+imxFlER9s5mSp+RarXZI4LEDvbrLSbaqQ7nV/pWcq
+K9J0B1j0nhPdH6Zc5rqFWAh/cas71yvAcJ9AwUpWEpPAAuXM64WvFH/vB8EolPCq
+8wBKe/ReHG9Kx0bt9qlCadeKhfNwGY1iWxCvlajVA0uwiQI+BBgBAgAJBQJP2kdF
+AhsuASkJEEhQjTEd00ExwF0gBBkBAgAGBQJP2kdFAAoJECErhjJBLl0hSJ8IAIk/
+bDJdQuYRY1myyH0SdQI8HoO4uQ2Abhi25tlmDjr9jqYVZg2vMQsF6Yp8P16IgAcR
+1vLdm704KWMIdEsBRmm9fnFhXBqHmzPZy0JU5jO0lpx0bmeGeDt0c6lx9wYLZxD6
+eEJq1enrPD7LWLTCD5zAXvpquIbOlFDCAAS03eR3aLsbq0eGHA3SK7TTPiZyAchM
+23UDcEu8j3Dl64s2Fq5Fce8q3pGfU4boN9LvZusNEkptNyEcmdU4CSE3EzkqPR1P
+mjislBxqqBtm5uiAeZqIDlid1KQqYUMm9w7oJcHBe/id+jrUYhANzry4xav0V7tk
+LuiqJsTnqGXI+SBZrL7TyQgAljolZDg31m+Emlz5OVLYudHiuUGMKYHNurGXNHFo
+GYM4m+Ch9JRPaQj7coEXUG4cq+nnNtGFMLbTAtcb5eynts4XbpdnqOOOIEdHhSTK
+l32DFezfUVeda+CXKA/0R11OlWP8lMwz67P12ha2RROd0vdeP+U53OsdTlFIMifc
+khEMSUDcsso3fn0kFcv0bPUePWkOOYYtmdFhMEdnqiOuA2Yd/30XanVwNck70S39
+kzAgLyWiy4yYJ7czK9cd38azGMhNTs75K0OmgTkCYREf/V5Tcmf4Tu3mD38+c4BA
+HzZyuo12Jkt3CWvXLoN0LHFHnS56KNOYpHWKPd3Z1HeD6w==
+=Xb/x
+-----END PGP PRIVATE KEY BLOCK-----

data/spec/support/fixtures/public_key.asc

@@ -0,0 +1,36 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+Version: GnuPG/MacGPG2 v2.0.17 (Darwin)
+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+=vAW+
+-----END PGP PUBLIC KEY BLOCK-----

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification 
+name: jruby-pgp
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+  - Scott Gonyea
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-11-17 00:00:00 Z
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: rake
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :development
+    version_requirements: *id001
+  - !ruby/object:Gem::Dependency 
+    name: rspec
+    prerelease: false
+    requirement: &id002 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :development
+    version_requirements: *id002
+  - !ruby/object:Gem::Dependency 
+    name: rake-compiler
+    prerelease: false
+    requirement: &id003 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :development
+    version_requirements: *id003
+description: PGP for JRuby
+email: 
+  - me@sgonyea.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - .gitignore
+  - .rspec
+  - Gemfile
+  - LICENSE.txt
+  - README.md
+  - Rakefile
+  - ext/org/sgonyea/pgp/Encryptor.java
+  - ext/org/sgonyea/pgp/PGP.java
+  - jruby-pgp.gemspec
+  - lib/jruby-pgp.rb
+  - lib/pgp.rb
+  - lib/pgp/decryptor.rb
+  - lib/pgp/encryptor.rb
+  - lib/pgp/jars/bcpg-jdk15on-147.jar
+  - lib/pgp/jars/bcprov-jdk15on-147.jar
+  - lib/pgp/private_key.rb
+  - lib/pgp/version.rb
+  - spec/lib/pgp/encryptor_spec.rb
+  - spec/spec_helper.rb
+  - spec/support/fixtures/private_key.asc
+  - spec/support/fixtures/public_key.asc
+  - lib/pgp/jruby-pgp.jar
+homepage: https://github.com/sgonyea/jruby-pgp
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: This is a Java+JRuby wrapper around the Bouncy Castle PGP APIs
+test_files: 
+  - spec/lib/pgp/encryptor_spec.rb
+  - spec/spec_helper.rb
+  - spec/support/fixtures/private_key.asc
+  - spec/support/fixtures/public_key.asc