jruby-pgp 0.1.2 → 0.2.0

data/bin/jrpgp

@@ -0,0 +1,12 @@
+#!/usr/bin/env jruby
+
+if $LOAD_PATH.grep('jruby-pgp').none?
+  lib_dir = File.expand_path('../../lib', __FILE__)
+  $LOAD_PATH.unshift lib_dir
+end
+
+require 'pgp/cli/runner'
+require 'pathname'
+require 'optparse'
+
+PGP::CLI::Runner.go!(ARGV)

data/jruby-pgp.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ['lib']
 
+  gem.add_dependency 'jruby-openssl'
+
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'rake-compiler'

data/lib/pgp.rb

@@ -10,6 +10,7 @@ require 'pgp/private_key'
 module PGP
   autoload :VERSION,        'pgp/version'
   autoload :RubyDecryptor,  'pgp/ruby_decryptor'
+  autoload :CLI,            'pgp/cli'
 
   BC_Provider_Code = "BC"
 

data/lib/pgp/cli.rb

@@ -0,0 +1,160 @@
+require 'pgp'
+
+module PGP
+  # Currently, this is pretty quick-and-dirty. I should expand options into accessor methods, I know.
+  class CLI
+    autoload :Runner, 'pgp/cli/runner'
+
+    attr_accessor :options, :opt_parser
+
+    Encrypted_Extension_Regexp = /\.(pgp|gpg|asc)$/i
+
+    def self.ensure_file_exists!(file)
+      raise "The file #{file.inspect} does not appear to exist!" unless File.exist?(file)
+    end
+
+    def self.ensure_dir_exists!(dir)
+      raise "The directory #{dir.inspect} does not appear to exist!" unless File.directory?(dir)
+    end
+
+    def initialize
+      self.options = {
+        :public_keys  => [],
+        :private_keys => [],
+        :input_files  => [],
+        :output_files => [],
+        :outdir       => Pathname(Dir.pwd),
+        :same_dir     => false,
+        :action       => nil,
+        :signature    => false, # We do not currently support signing or verifying signatures
+      }
+    end
+
+    def [](arg)
+      options[arg]
+    end
+
+    def []=(arg, val)
+      options[arg] = val
+    end
+
+    def validate_options!
+      raise "Input file(s) must be specified!" if input_files.none?
+
+      case action
+      when :encrypt then validate_encrypt_options!
+      when :decrypt then validate_decrypt_options!
+      else
+        raise "Valid actions are encrypt or decrypt. Action specified: #{options[:action]}"
+      end
+
+    rescue RuntimeError => e
+      $stderr.puts opt_parser
+      raise e
+    end
+
+    def run!
+      validate_options!
+
+      case options[:action]
+      when :encrypt then encrypt!
+      when :decrypt then decrypt!
+      end
+    end
+
+    def encrypt!
+      cryptor = Encryptor.new
+
+      public_keys.each {|pub| cryptor.add_keys_from_file(pub) }
+
+      input_files.each_with_index do |infile, idx|
+        outfile = output_files[idx]
+        output  = cryptor.encrypt_file(infile)
+
+        File.open(outfile, "w") do |fi|
+          fi.write output
+        end
+      end
+    end
+
+    def decrypt!
+      cryptor = Decryptor.new
+
+      private_keys.each {|priv| cryptor.add_keys_from_file(priv) }
+
+      input_files.each_with_index do |infile, idx|
+        outfile = output_files[idx]
+        output  = cryptor.decrypt_file(infile)
+
+        File.open(outfile, "w") do |fi|
+          fi.write output
+        end
+      end
+    end
+
+    def action
+      options[:action] ||= begin
+        if input_files.grep(Encrypted_Extension_Regexp).any?
+          :decrypt
+        else
+          :encrypt
+        end
+      end
+    end
+
+    def public_keys
+      options[:public_keys]
+    end
+
+    def private_keys
+      options[:private_keys]
+    end
+
+    def input_files
+      options[:input_files]
+    end
+
+    def output_files
+      options[:output_files]
+    end
+
+    def outdir
+      options[:outdir]
+    end
+
+    def same_dir?
+      options[:same_dir]
+    end
+
+    protected
+    def set_outfile_dir(file)
+      return file if same_dir?
+      outdir + File.basename(file)
+    end
+
+    def validate_encrypt_options!
+      raise "Public Keys are required for encryption"     if options[:public_keys].none?
+      raise "Private Keys are required for signing files" if options[:signature] and options[:private_keys].none?
+
+      options[:input_files].each_with_index do |infile, idx|
+        next if options[:output_files][idx]
+        options[:output_files][idx] = set_outfile_dir("#{infile}.gpg")
+      end
+    end
+
+    def validate_decrypt_options!
+      raise "Private Keys are required for decryption"          if options[:private_keys].none?
+      raise "Public Keys are required for verifying signatures" if options[:signature] and options[:public_keys].none?
+
+      options[:input_files].each_with_index do |infile, idx|
+        next if options[:output_files][idx]
+
+        outfile = infile.gsub(Encrypted_Extension_Regexp, '')
+        outfile = "#{infile} - decrypted" if outfile == infile
+
+        options[:output_files][idx] = set_outfile_dir(outfile)
+      end
+    end
+
+  end
+end

data/lib/pgp/cli/runner.rb

@@ -0,0 +1,78 @@
+require 'pgp/cli'
+
+module PGP
+  # Currently, this is pretty quick-and-dirty. I should expand options into accessor methods, I know.
+  class CLI
+    module Runner
+
+      def self.go!(args)
+        cli = parse_args!(args)
+        cli.run!
+      end
+
+      def self.parse_args!(args)
+        cli = PGP::CLI.new
+
+        cli.opt_parser = OptionParser.new do |opts|
+          opts.banner = "Usage: jrpgp [options] file [file2] [file3] [...]"
+
+          opts.on("-e", "--encrypt", "Perform Encryption") do
+            cli[:action] = :encrypt
+          end
+
+          opts.on("-d", "--decrypt", "Perform Decryption") do
+            cli[:action] = :decrypt
+          end
+
+          opts.on("-p", "--pub-key [file]", String, "The file containing Public Key(s) to encrypt to") do |fi|
+            PGP::CLI.ensure_file_exists!(fi)
+            cli[:public_keys] << fi
+          end
+
+          opts.on("-P", "--priv-key [file]", String, "The file containing Private Key(s) to use for decryption / signing") do |fi|
+            PGP::CLI.ensure_file_exists!(fi)
+            cli[:private_keys] << fi
+          end
+
+          opts.on("-i", "--in [file]", String, "The file to encrypt/decrypt") do |fi|
+            PGP::CLI.ensure_file_exists!(fi)
+            cli[:input_files] << fi
+          end
+
+          opts.on("-o", "--out [file]", String, "The file to output") do |fi|
+            cli[:output_files] << fi
+          end
+
+          opts.on("-O", "--out-dir [dir]", String, "The directory where output files should be written") do |dir|
+            PGP::CLI.ensure_dir_exists!(dir)
+            cli[:outdir] = Pathname(dir).expand_path
+          end
+
+          opts.separator ""
+
+          opts.on_tail("-h", "--help", "Show this message") do
+            puts opts
+            exit
+          end
+
+          # Another typical switch to print the version.
+          opts.on_tail("--version", "Show version") do
+            puts PGP::VERSION.join('.')
+            exit
+          end
+        end
+
+        cli.opt_parser.parse!(args)
+
+        args.each do |file|
+          PGP::CLI.ensure_file_exists!(file)
+          cli[:input_files] << file
+        end
+
+        cli
+      end
+
+    end
+  end
+end
+

data/lib/pgp/decryptor.rb

@@ -16,6 +16,10 @@ module PGP
       String.from_java_bytes(decrypted_data)
     end
 
+    def decrypt_file(file_path)
+      decrypt File.read(file_path)
+    end
+
     protected
     def keyring_from_file(filename)
       file = File.open(filename)

data/lib/pgp/version.rb

@@ -1,3 +1,3 @@
 module PGP
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
 end

data/spec/lib/pgp/cli_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'fileutils'
+
+describe PGP::CLI 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 }
+
+  let(:decrypted_file)  { Fixtures_Path.join('unencrypted_file.txt').to_s }
+  let(:encrypted_file)  { Fixtures_Path.join('unencrypted_file.txt.asc').to_s }
+
+  after {
+    # These files are created in our current working directory
+    FileUtils.rm_rf('unencrypted_file.txt.gpg')
+    FileUtils.rm_rf('unencrypted_file.txt')
+  }
+
+
+  describe 'Encrypting' do
+    it "should encrypt a given file to the given public key" do
+      PGP::CLI::Runner.go!([decrypted_file, "-p", "spec/support/fixtures/public_key.asc"])
+
+      File.exist?('unencrypted_file.txt.gpg').should be_true
+    end
+  end
+
+  describe 'Decrypting' do
+    it "should decrypt a given file to the given private key" do
+      PGP::CLI::Runner.go!([encrypted_file, "-P", "spec/support/fixtures/private_key.asc", "-d"])
+
+      File.exist?('unencrypted_file.txt').should be_true
+    end
+  end
+
+  describe 'Public Keys'
+
+  describe 'Private Keys'
+
+  describe 'Input Files'
+
+  describe 'Output Files'
+end

metadata

@@ -2,7 +2,7 @@
 name: jruby-pgp
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors: 
   - Scott Gonyea
@@ -10,10 +10,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-11-22 00:00:00 Z
+date: 2013-01-04 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
-    name: rake
+    name: jruby-openssl
     prerelease: false
     requirement: &id001 !ruby/object:Gem::Requirement 
       none: false
@@ -21,10 +21,10 @@ dependencies:
         - - ">="
           - !ruby/object:Gem::Version 
             version: "0"
-    type: :development
+    type: :runtime
     version_requirements: *id001
   - !ruby/object:Gem::Dependency 
-    name: rspec
+    name: rake
     prerelease: false
     requirement: &id002 !ruby/object:Gem::Requirement 
       none: false
@@ -35,7 +35,7 @@ dependencies:
     type: :development
     version_requirements: *id002
   - !ruby/object:Gem::Dependency 
-    name: rake-compiler
+    name: rspec
     prerelease: false
     requirement: &id003 !ruby/object:Gem::Requirement 
       none: false
@@ -45,11 +45,22 @@ dependencies:
             version: "0"
     type: :development
     version_requirements: *id003
+  - !ruby/object:Gem::Dependency 
+    name: rake-compiler
+    prerelease: false
+    requirement: &id004 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :development
+    version_requirements: *id004
 description: PGP for JRuby
 email: 
   - me@sgonyea.com
-executables: []
-
+executables: 
+  - jrpgp
 extensions: []
 
 extra_rdoc_files: []
@@ -61,11 +72,14 @@ files:
   - LICENSE.txt
   - README.md
   - Rakefile
+  - bin/jrpgp
   - ext/org/sgonyea/pgp/Decryptor.java
   - ext/org/sgonyea/pgp/Encryptor.java
   - jruby-pgp.gemspec
   - lib/jruby-pgp.rb
   - lib/pgp.rb
+  - lib/pgp/cli.rb
+  - lib/pgp/cli/runner.rb
   - lib/pgp/decryptor.rb
   - lib/pgp/encryptor.rb
   - lib/pgp/jars/bcpg-jdk15on-147.jar
@@ -73,6 +87,7 @@ files:
   - lib/pgp/private_key.rb
   - lib/pgp/ruby_decryptor.rb
   - lib/pgp/version.rb
+  - spec/lib/pgp/cli_spec.rb
   - spec/lib/pgp/decryptor_spec.rb
   - spec/lib/pgp/encryptor_spec.rb
   - spec/spec_helper.rb
@@ -104,11 +119,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.9
 signing_key: 
 specification_version: 3
 summary: This is a Java+JRuby wrapper around the Bouncy Castle PGP APIs
 test_files: 
+  - spec/lib/pgp/cli_spec.rb
   - spec/lib/pgp/decryptor_spec.rb
   - spec/lib/pgp/encryptor_spec.rb
   - spec/spec_helper.rb