metafusion-crypto 0.1.0

data/lib/metafusion/crypto.rb

@@ -0,0 +1,10 @@
+module Metafusion
+  module Crypto
+  end
+end
+
+require 'base64'
+
+require 'metafusion/crypto/version'
+require 'metafusion/crypto/meta'
+require 'metafusion/crypto/base'

data/lib/metafusion/crypto/base.rb

@@ -0,0 +1,132 @@
+# Cryptography helper module <tt>Metafusion::Crypto</tt> as well as
+# <tt>Metafusion::Crypto::PrivateKey</tt> and 
+# <tt>Metafusion::Crypto::DigitalSignature</tt> classes.
+
+require 'openssl'
+require 'digest/sha1'
+
+# Module that contains Cryptography helper methods and the 
+# <tt>Metafusion::Crypto::Key</tt> class to be utilized in 
+# public key encryption.
+module Metafusion::Crypto
+
+  # Generate private and public keys
+  # 1. <tt>private_file</tt> - file name of private key to generate (default = "rsa_key")
+  # 2. <tt>public_file</tt> - file name of public key to generate (default = "#{private_key}.pub")
+  # 3. <tt>bits</tt> - number of bits for key (default = 1024)
+  # 4. <tt>clean</tt> - specifies if existing key files should
+  #    zapped and replaced by newly generated keys (default = true)
+  # 
+  # Returns the private key generated.
+  # 
+  # Usage:
+  #   priv_key = Metafusion::Crypto.generate_key_pair
+  def self.generate_key_pair(private_file = "rsa_key", 
+                         public_file = "#{private_file}.pub", 
+                         bits = 512, clean = true)
+    if clean
+      File.delete(private_file) if File.exists?(private_file)
+      File.delete(public_file) if File.exists?(public_file)
+    end
+    private_key = OpenSSL::PKey::RSA.new(bits)
+    File.open(private_file, "w+") do |fp| 
+      fp << private_key.to_s
+    end
+    File.open(public_file,  "w+") do |fp| 
+      fp << private_key.public_key.to_s
+    end
+    private_key
+  end
+  
+  # <tt>Metafusion::Crypto::DigitalSignature</tt> provides easier 
+  # a more streamlined API to create digital signatures without 
+  # needing to know what that entails.
+  # 
+  # Usage:
+  #  include Metafusion::Crypto
+  #  sig = DigitalSignature.from_file('rsa_key.pub', 'rsa_key')
+  #  original_text = "my clear text message"
+  #  crypted_text = sig.encrypt(original_text)
+  #  plain_text = sig.decrypt(crypted_text)
+  #  puts "It worked - let's celebrate!" if original_text == plain_text
+  class DigitalSignature
+    # Class methods
+    class << self
+      # Loads and constructs key from file <tt>private_filename</tt> given.
+      def from_keys(public_filename = "rsa_key.pub", 
+                         private_filename = nil)
+        return self.new(File.read(public_filename)) unless private_filename
+        self.new(File.read(public_filename), File.read(private_filename))
+      end
+    end
+
+    # Constructor that takes the private and public key data.
+    # Only the <tt>public_data</tt> is required since not all
+    # <tt>DigitalSignature</tt> class clients will have access 
+    # to the private key.
+    def initialize(public_data, private_data = nil)
+      @private_key = OpenSSL::PKey::RSA.new(private_data) if private_data
+      @public_key = OpenSSL::PKey::RSA.new(public_data)
+    end
+  
+    # Encrypts given <tt>text</tt> using key instance.  This assumes
+    # that private key data was provided at instantiation step.
+    def encrypt(text)
+      Base64.encode64(@private_key.send("private_encrypt", text)) if @private_key
+    end
+    
+    # Decrypts given <tt>text</tt> using key instance.
+    def decrypt(text)
+      @public_key.send("public_decrypt", Base64.decode64(text))
+    end
+    
+    private
+      attr_accessor :private_key, :public_key
+  end
+
+  # <tt>Metafusion::Crypto::PrivateKey</tt> provides class that wraps 
+  # the boilerplate private key encryption API from the Ruby 
+  # standard library OpenSSL implementation.
+  # 
+  # Usage:
+  #  include Metafusion::Crypto
+  #  pkey = PrivateKey.new('mypassphrase')
+  #  original_text = 'Yo yo yo.  What up dog?'
+  #  crypted_text = pkey.encrypt(original_text)
+  #  plain_text = pkey.decrypt(crypted_text)
+  #  puts "Let's roll and celebrate - it worked" if original_text == plain_text
+  class PrivateKey
+    # Class methods
+    class << self
+      # Read in private key from file
+      def from_file(key_file = 'rsa_key')
+        return self.new(File.read(key_file))
+      end
+    end
+  
+    # Creates <tt>PrivateKey</tt> instance given
+    # <tt>raw_passphrase</tt> and <tt>cipher</tt>.
+    # The default cipher is AES-256-CBC.
+    def initialize(raw_passphrase, cipher = "aes-256-cbc")
+      @encrypt_cipher = OpenSSL::Cipher::Cipher.new(cipher)
+      @decrypt_cipher = OpenSSL::Cipher::Cipher.new(cipher)
+      @key = Digest::SHA1.hexdigest(raw_passphrase)
+    end
+    
+    # Encrypts given <tt>text</tt> using key instance
+    def encrypt(text)
+      @encrypt_cipher.encrypt(@key)
+      s = @encrypt_cipher.update(text)
+      s << @encrypt_cipher.final
+      Base64.encode64(s)
+    end
+    
+    # Decrypts given <tt>text</tt> using key instance
+    def decrypt(text)
+      @decrypt_cipher.decrypt(@key)
+      s = @decrypt_cipher.update(Base64.decode64(text))
+      s << @decrypt_cipher.final
+      s
+    end
+  end
+end

data/lib/metafusion/crypto/meta.rb

@@ -0,0 +1,57 @@
+# meta.rb contains <tt>Metafusion::Crypto::Meta</tt> and related classes that
+# help define the metadata of the <tt>Metafusion::Crypto4R</tt> project.
+
+require('rubygems')
+require('erb')
+
+class Metafusion::Crypto::Meta #:nodoc:
+  attr_accessor :root_dir
+  attr_reader :gem_spec, :project_files, :spec_files
+
+  # Initializer for Metafusion::Crypto::Meta class.  Takes <tt>root_dir</tt> as parameter.
+  def initialize(root_dir)
+    @root_dir = root_dir
+  end
+
+  # Returns package information defined in <tt>root_dir</tt>/pkg-info.yml
+  def pkg_info
+    yaml_file = File.join(@root_dir, 'pkg-info.yml')
+    ryaml = ERB.new(File.read(yaml_file), 0)
+    s = ryaml.result(binding)
+    YAML.load(s)
+  end
+  
+  # Returns RubyGems spec information
+  def spec_info
+    self.pkg_info['spec'] if self.pkg_info
+  end
+  
+  # Returns list of project files
+  def project_files
+    @project_files ||= Dir.glob(File.join(@root_dir, 'lib/**/*.rb'))
+    @project_files
+  end
+  
+  # Returns list of specification files
+  def spec_files
+    @spec_files ||= Dir.glob(File.join(@root_dir, 'spec/**/*_spec.rb'))
+    @spec_files
+  end
+  
+  # Returns RubyGem specification for Metafusion::Crypto project
+  def gem_spec
+    @gem_spec ||= Gem::Specification.new do |spec|
+      self.spec_info.each do |key, val|
+#        if val.is_a?(Hash)
+#          puts val.inspect
+#          val.each do |k, v|
+#            spec.send(key, k, v)
+#          end
+#        else
+          spec.send("#{key}=", val)
+#        end
+      end
+    end
+    @gem_spec
+  end
+end

data/lib/metafusion/crypto/version.rb

@@ -0,0 +1,19 @@
+# version.rb contains <tt>Metafusion::Crypto::Version</tt> that provides helper
+# methods related to versioning of the <tt>Metafusion::Crypto4R</tt> project.
+
+module Metafusion::Crypto::Version #:nodoc:
+  MAJOR = 0
+  MINOR = 1
+  REVISION = 0
+  class << self
+    # Returns X.Y.Z formatted version string
+    def to_version
+      "#{MAJOR}.#{MINOR}.#{REVISION}"
+    end
+    
+    # Returns X-Y-Z formatted version name
+    def to_name
+      "#{MAJOR}_#{MINOR}_#{REVISION}"
+    end
+  end
+end

data/spec/metafusion/crypto/base_spec.rb

@@ -0,0 +1,113 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+PRIVATE_KEY = 'rsa_key'
+PUBLIC_KEY = 'rsa_key.pub'
+
+def remove_rsa_keys(priv = PRIVATE_KEY, pub = PUBLIC_KEY)
+    File.delete(priv) if File.exists?(priv)
+    File.delete(pub) if File.exists?(pub)
+end
+
+describe Metafusion::Crypto, ".generate_key_pair" do
+  before(:each) do
+    remove_rsa_keys
+  end
+  
+  it "should create a private and public RSA key pair" do
+    Metafusion::Crypto.generate_key_pair
+    File.exists?(PRIVATE_KEY).should be_true
+    File.exists?(PUBLIC_KEY).should be_true
+  end
+  
+  after(:each) do
+    remove_rsa_keys
+  end
+end
+
+describe Metafusion::Crypto::DigitalSignature do
+  before(:each) do
+    # ensure the keys are generated
+    Metafusion::Crypto.generate_key_pair
+    @private_key = "private key"
+    @public_key = "public key"
+    File.stub!(:read).and_return(@public_key, @private_key)
+  end
+  
+  it "should create instance from from_keys class method" do
+    Metafusion::Crypto::DigitalSignature.should_receive(:new).with(@public_key,@private_key)
+    Metafusion::Crypto::DigitalSignature.from_keys(PUBLIC_KEY, PRIVATE_KEY)
+  end
+  
+  it "should create instance from from_keys class method using private key data when only public key provided" do
+    Metafusion::Crypto::DigitalSignature.should_receive(:new).with(@public_key)
+    Metafusion::Crypto::DigitalSignature.from_keys(PUBLIC_KEY)
+  end
+  
+  after(:each) do
+    remove_rsa_keys
+  end
+end
+
+describe Metafusion::Crypto::DigitalSignature do
+  before(:each) do
+    @original_text = "Charlotte Bronte rules"
+    Metafusion::Crypto.generate_key_pair
+    @digital_signature = Metafusion::Crypto::DigitalSignature.from_keys('rsa_key.pub', 'rsa_key')
+  end
+  
+  it "should encrypt/decrypt round-trip back to original text" do
+    crypted_text = @digital_signature.encrypt(@original_text)
+    decrypted_text = @digital_signature.decrypt(crypted_text)
+    decrypted_text.should eql(@original_text)
+  end
+  
+  it "should encrypt original text to a 90 character base64 string" do
+    crypted_text = @digital_signature.encrypt(@original_text)
+    crypted_text.size.should be(90)
+  end
+  
+  after(:each) do
+    remove_rsa_keys
+  end
+end
+
+describe Metafusion::Crypto::PrivateKey do
+  before(:each) do
+    @original_text = "Was Jane Eyre the ultimate feminist?"
+    @private_key = Metafusion::Crypto::PrivateKey.new("currerbell1847")
+  end
+  
+  it "should encrypt/decrypt round-trip back to original text" do
+    crypted_text = @private_key.encrypt(@original_text)
+    decrypted_text = @private_key.decrypt(crypted_text)
+    decrypted_text.should eql(@original_text)
+  end
+  
+  after(:each) do
+    remove_rsa_keys
+  end
+end
+
+describe Metafusion::Crypto::PrivateKey, ".from_file" do
+  before(:each) do
+    @file_name = "key_file"
+    @key_content = "the key goes here"
+    File.stub!(:read).and_return(@key_content)
+    @pkey = mock(Metafusion::Crypto::PrivateKey)
+  end
+  
+  it "should create new instance of PrivateKey with contents of key file supplied" do
+    Metafusion::Crypto::PrivateKey.should_receive(:new).with(@key_content).and_return(@pkey)
+    Metafusion::Crypto::PrivateKey.from_file(@file_name)
+  end
+  
+  it "should read contents of file given" do
+    File.should_receive(:read).with(@file_name).and_return("")
+    Metafusion::Crypto::PrivateKey.from_file(@file_name)
+  end
+  
+  after(:each) do
+    @pkey = nil
+    @file_name = nil
+  end
+end

data/spec/metafusion/crypto/meta_spec.rb

@@ -0,0 +1,90 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+def glob_files(*path_elements)
+  Dir.glob(File.join(*path_elements))
+end
+
+def load_erb_yaml(path, context)
+  ryaml = ERB.new(File.read(path), 0)
+  YAML.load(ryaml.result(context))
+end
+
+module ERBMetaMixin
+  # Needed to make the YAML load work...
+  def project_files
+    glob_files(@root_dir, 'lib', '**/*.rb')
+  end
+
+  # Needed to make the YAML load work...
+  def spec_files
+    glob_files(@root_dir, 'spec', '**/*_spec.rb')
+  end
+end
+
+describe "Metafusion::Crypto::Meta cache policy" do
+  include ERBMetaMixin
+  before(:each) do
+    @root_dir = project_root_dir
+    @meta = Metafusion::Crypto::Meta.new(@root_dir)
+    @expected_pkg_info = load_erb_yaml(File.join(@root_dir, 'pkg-info.yml'), binding)
+    @expected_project_files = project_files
+    @expected_spec_files = spec_files
+  end
+  
+  it "should store value returned from project_files in @project_files after first glob" do
+    @meta.instance_eval("@project_files").should eql(nil)
+    @meta.project_files
+    @meta.instance_eval("@project_files").should eql(@expected_project_files)
+    @meta.project_files
+    @meta.instance_eval("@project_files").should eql(@expected_project_files)
+  end
+  
+  it "should store value returned from spec_files in @spec_files after first glob" do
+    @meta.instance_eval("@spec_files").should eql(nil)
+    @meta.spec_files
+    @meta.instance_eval("@spec_files").should eql(@expected_spec_files)
+    @meta.spec_files
+    @meta.instance_eval("@spec_files").should eql(@expected_spec_files)
+  end
+end
+
+describe "Metafusion::Crypto::Meta" do
+  include ERBMetaMixin
+  before(:each) do
+    @root_dir = project_root_dir
+    @meta = Metafusion::Crypto::Meta.new(@root_dir)
+    @expected_yaml_hash = load_erb_yaml(File.join(@root_dir, 'pkg-info.yml'), binding)
+    @expected_project_files = project_files
+    @expected_spec_files = spec_files
+  end
+  
+  it "should load and return YAML file into Hash object upon #pkg_info call" do
+    yaml_hash = @meta.pkg_info
+    yaml_hash.should.eql? @expected_yaml_hash
+  end
+  
+  it "should return the embedded hash responding to key 'spec' of #pkg_info call upon #spec_info call" do
+    yaml_hash = @meta.spec_info
+    yaml_hash.should.eql? @expected_yaml_hash['spec']
+  end
+  
+  it "should return list of files matching ROOT_DIR/lib/**/*.rb upon #project_files call" do
+    project_files = @meta.project_files
+    project_files.should.eql? @expected_project_files
+  end
+  
+  it "should return list of files matching ROOT_DIR/spec/**/*.rb upon #spec_files call" do
+    spec_files = @meta.spec_files
+    spec_files.should.eql? @expected_spec_files    
+  end
+  
+  it "should return Gem specification based on YAML file contents and #project_files and #spec_files return values" do
+    spec = @meta.gem_spec
+    expected_spec_hash = @expected_yaml_hash['spec']
+    expected_spec_hash.each do |key, val|
+      unless val.is_a?(Hash)
+        spec.send(key).to_s.should eql(expected_spec_hash[key].to_s)
+      end
+    end
+  end
+end

data/spec/metafusion/crypto/version_spec.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+VERSION_LIST = [Metafusion::Crypto::Version::MAJOR, Metafusion::Crypto::Version::MINOR, Metafusion::Crypto::Version::REVISION]
+
+EXPECTED_VERSION = VERSION_LIST.join('.')
+EXPECTED_NAME = VERSION_LIST.join('_')
+
+describe Metafusion::Crypto::Version, ".to_version" do
+  it "should return #{EXPECTED_VERSION}" do
+    Metafusion::Crypto::Version.to_version.should eql(EXPECTED_VERSION)
+  end
+end
+
+describe Metafusion::Crypto::Version, ".to_name" do
+  it "should return #{EXPECTED_NAME}" do
+    Metafusion::Crypto::Version.to_name.should eql(EXPECTED_NAME)
+  end
+end
+

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: metafusion-crypto
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-09-30 00:00:00 -05:00
+summary: Provides private key and digital signature encryption mechanisms for application developers that do not want to worry about the details.
+require_paths: 
+- lib
+email: metafusion@googlegroups.com
+homepage: http://metafusion.rubyforge.org
+rubyforge_project: metafusion
+description: 
+autorequire: metafusion/crypto
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.2
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Susan Potter
+files: 
+- lib/metafusion/crypto.rb
+- lib/metafusion/crypto/base.rb
+- lib/metafusion/crypto/version.rb
+- lib/metafusion/crypto/meta.rb
+- spec/metafusion/crypto/base_spec.rb
+- spec/metafusion/crypto/version_spec.rb
+- spec/metafusion/crypto/meta_spec.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: 
+- Ruby 1.8.4+
+- jcode (for unicode support)
+dependencies: []
+