encryptor 1.1.0 → 1.1.1

data/README.rdoc

@@ -12,16 +12,38 @@ Used by http://github.com/shuber/attr_encrypted to easily encrypt/decrypt attrib
 
 == Usage
 
-  secret_key = Digest::SHA256.hexdigest('a secret key')
+
+=== Basic
+
   encrypted_value = Encryptor.encrypt(:value => 'some string to encrypt', :key => secret_key) # '������{)��q�ށ�ܣ��q���Au/�ޜP'
   decrypted_value = Encryptor.decrypt(:value => encrypted_value, :key => secret_key) # 'some string to encrypt'
 
+The value to encrypt or decrypt may also be passed as the first argument if you'd like.
+
+  secret_key = Digest::SHA256.hexdigest('a secret key')
+  encrypted_value = Encryptor.encrypt('some string to encrypt', :key => secret_key) # '������{)��q�ށ�ܣ��q���Au/�ޜP'
+  decrypted_value = Encryptor.decrypt(encrypted_value, :key => secret_key) # 'some string to encrypt'
+
 You may also pass the <tt>:iv</tt> and <tt>:algorithm</tt> options but they are not required. If an algorithm is not specified, the Encryptor uses
 the algorithm found at <tt>Encryptor.default_options[:algorithm]</tt> which is <tt>aes-256-cbc</tt> by default. You can change the default options 
 by overwriting or merging this attribute:
 
   Encryptor.default_options.merge!(:algorithm => 'bf', :key => 'some default secret key')
 
+
+=== Strings
+
+<tt>Encryptor</tt> adds <tt>encrypt</tt> and <tt>decrypt</tt> methods to <tt>String</tt> objects for your convenience. These two methods accept the same arguments as the associated ones in the <tt>Encryptor</tt> module. There nice when you set the default options in the <tt>Encryptor.default_options</tt> attribute. For example:
+
+  Encryptor.default_options.merge!(:key => 'some default secret key')
+  credit_card = 'xxxx xxxx xxxx 1234'
+  encrypted_credit_card = credit_card.encrypt
+
+There's also <tt>encrypt!</tt> and <tt>decrypt!</tt> methods that replace the contents of a string with the encrypted or decrypted version of itself.
+
+
+=== Algorithms
+
 Run <tt>openssl list-cipher-commands</tt> in your terminal to view a list all cipher algorithms that are supported on your platform.
 
   aes-128-cbc
@@ -30,7 +52,6 @@ Run <tt>openssl list-cipher-commands</tt> in your terminal to view a list all ci
   aes-192-ecb
   aes-256-cbc
   aes-256-ecb
-  base64
   bf
   bf-cbc
   bf-cfb

data/lib/encryptor.rb

@@ -1,5 +1,7 @@
 require 'openssl'
+require 'encryptor/string'
 
+# A simple wrapper for the standard OpenSSL library
 module Encryptor
   # The default options to use when calling the <tt>encrypt</tt> and <tt>decrypt</tt> methods
   #
@@ -16,9 +18,11 @@ module Encryptor
   #
   # Example
   #
-  #   encrypted_value = Huberry::Encryptor.encrypt(:value => 'some string to encrypt', :key => 'some secret key')
-  def self.encrypt(options)
-    crypt :encrypt, options
+  #   encrypted_value = Encryptor.encrypt(:value => 'some string to encrypt', :key => 'some secret key')
+  #   # or
+  #   encrypted_value = Encryptor.encrypt('some string to encrypt', :key => 'some secret key')
+  def self.encrypt(*args)
+    crypt :encrypt, *args
   end
   
   # Decrypts a <tt>:value</tt> with a specified <tt>:key</tt>
@@ -27,15 +31,17 @@ module Encryptor
   #
   # Example
   #
-  #   decrypted_value = Huberry::Encryptor.decrypt(:value => 'some encrypted string', :key => 'some secret key')
-  def self.decrypt(options)
-    crypt :decrypt, options
+  #   decrypted_value = Encryptor.decrypt(:value => 'some encrypted string', :key => 'some secret key')
+  #   # or
+  #   decrypted_value = Encryptor.decrypt('some encrypted string', :key => 'some secret key')
+  def self.decrypt(*args)
+    crypt :decrypt, *args
   end
   
   protected
   
-    def self.crypt(cipher_method, options = {})
-      options = default_options.merge(options)
+    def self.crypt(cipher_method, *args) #:nodoc:
+      options = default_options.merge(:value => args.first).merge(args.last.is_a?(Hash) ? args.last : {})
       cipher = OpenSSL::Cipher::Cipher.new(options[:algorithm])
       cipher.send(cipher_method)
       if options[:iv]
@@ -47,4 +53,6 @@ module Encryptor
       result = cipher.update(options[:value])
       result << cipher.final
     end
-end
+end
+
+String.send :include, Encryptor::String

data/lib/encryptor/string.rb

@@ -0,0 +1,24 @@
+module Encryptor #:nodoc:
+  # Adds <tt>encrypt</tt> and <tt>decrypt</tt> methods to strings
+  module String
+    # Returns a new string containing the encrypted version of itself
+    def encrypt(options = {})
+      Encryptor.encrypt(options.merge(:value => self))
+    end
+    
+    # Replaces the contents of a string with the encrypted version of itself
+    def encrypt!(options ={})
+      replace encrypt(options)
+    end
+  
+    # Returns a new string containing the decrypted version of itself
+    def decrypt(options = {})
+      Encryptor.decrypt(options.merge(:value => self))
+    end
+    
+    # Replaces the contents of a string with the decrypted version of itself
+    def decrypt!(options ={})
+      replace decrypt(options)
+    end
+  end
+end

data/test/encryptor_test.rb

@@ -4,40 +4,90 @@ require File.dirname(__FILE__) + '/../lib/encryptor'
 
 class EncryptorTest < Test::Unit::TestCase
   
-  algorithms = %x(openssl list-cipher-commands).split  
-  original_value = Digest::SHA256.hexdigest(([Time.now.to_s] * rand(3)).join)
+  algorithms = %x(openssl list-cipher-commands).split
   key = Digest::SHA256.hexdigest(([Time.now.to_s] * rand(3)).join)
   iv = Digest::SHA256.hexdigest(([Time.now.to_s] * rand(3)).join)
-  
-  algorithms.each do |algorithm|
-    define_method "test_should_crypt_with_#{algorithm}_algorithm_with_iv" do
-      encrypted_value = Encryptor.encrypt(:value => original_value, :key => key, :iv => iv, :algorithm => algorithm)
-      assert_not_equal original_value, encrypted_value
-      assert_not_equal Encryptor.encrypt(:value => original_value, :key => key, :algorithm => algorithm), encrypted_value
-      assert_equal original_value, Encryptor.decrypt(:value => encrypted_value, :key => key, :iv => iv, :algorithm => algorithm)
+  original_value = Digest::SHA256.hexdigest(([Time.now.to_s] * rand(3)).join)
+
+  algorithms.reject { |algorithm| algorithm == 'base64' }.each do |algorithm|
+    encrypted_value_with_iv = Encryptor.encrypt(:value => original_value, :key => key, :iv => iv, :algorithm => algorithm)
+    encrypted_value_without_iv = Encryptor.encrypt(:value => original_value, :key => key, :algorithm => algorithm)
+    
+    define_method "test_should_crypt_with_the_#{algorithm}_algorithm_with_iv" do
+      assert_not_equal original_value, encrypted_value_with_iv
+      assert_not_equal encrypted_value_without_iv, encrypted_value_with_iv
+      assert_equal original_value, Encryptor.decrypt(:value => encrypted_value_with_iv, :key => key, :iv => iv, :algorithm => algorithm)
     end
     
-    define_method "test_should_crypt_with_#{algorithm}_algorithm_without_iv" do
-      encrypted_value = Encryptor.encrypt(:value => original_value, :key => key, :algorithm => algorithm)
-      assert_not_equal original_value, encrypted_value
-      assert_equal original_value, Encryptor.decrypt(:value => encrypted_value, :key => key, :algorithm => algorithm)
+    define_method "test_should_crypt_with_the_#{algorithm}_algorithm_without_iv" do
+      assert_not_equal original_value, encrypted_value_without_iv
+      assert_equal original_value, Encryptor.decrypt(:value => encrypted_value_without_iv, :key => key, :algorithm => algorithm)
+    end
+    
+    define_method "test_should_encrypt_with_the_#{algorithm}_algorithm_with_iv_with_the_first_arg_as_the_value" do
+      assert_equal encrypted_value_with_iv, Encryptor.encrypt(original_value, :key => key, :iv => iv, :algorithm => algorithm)
+    end
+    
+    define_method "test_should_encrypt_with_the_#{algorithm}_algorithm_without_iv_with_the_first_arg_as_the_value" do
+      assert_equal encrypted_value_without_iv, Encryptor.encrypt(original_value, :key => key, :algorithm => algorithm)
+    end
+    
+    define_method "test_should_decrypt_with_the_#{algorithm}_algorithm_with_iv_with_the_first_arg_as_the_value" do
+      assert_equal original_value, Encryptor.decrypt(encrypted_value_with_iv, :key => key, :iv => iv, :algorithm => algorithm)
+    end
+    
+    define_method "test_should_decrypt_with_the_#{algorithm}_algorithm_without_iv_with_the_first_arg_as_the_value" do
+      assert_equal original_value, Encryptor.decrypt(encrypted_value_without_iv, :key => key, :algorithm => algorithm)
+    end
+    
+    define_method "test_should_call_encrypt_on_a_string_with_the_#{algorithm}_algorithm_with_iv" do
+      assert_equal encrypted_value_with_iv, original_value.encrypt(:key => key, :iv => iv, :algorithm => algorithm)
+    end
+    
+    define_method "test_should_call_encrypt_on_a_string_with_the_#{algorithm}_algorithm_without_iv" do
+      assert_equal encrypted_value_without_iv, original_value.encrypt(:key => key, :algorithm => algorithm)
+    end
+    
+    define_method "test_should_call_decrypt_on_a_string_with_the_#{algorithm}_algorithm_with_iv" do
+      assert_equal original_value, encrypted_value_with_iv.decrypt(:key => key, :iv => iv, :algorithm => algorithm)
+    end
+    
+    define_method "test_should_call_decrypt_on_a_string_with_the_#{algorithm}_algorithm_without_iv" do
+      assert_equal original_value, encrypted_value_without_iv.decrypt(:key => key, :algorithm => algorithm)
+    end
+    
+    define_method "test_string_encrypt!_on_a_string_with_the_#{algorithm}_algorithm_with_iv" do
+      original_value_dup = original_value.dup
+      original_value_dup.encrypt!(:key => key, :iv => iv, :algorithm => algorithm)
+      assert_equal original_value.encrypt(:key => key, :iv => iv, :algorithm => algorithm), original_value_dup
+    end
+    
+    define_method "test_string_encrypt!_on_a_string_with_the_#{algorithm}_algorithm_without_iv" do
+      original_value_dup = original_value.dup
+      original_value_dup.encrypt!(:key => key, :algorithm => algorithm)
+      assert_equal original_value.encrypt(:key => key, :algorithm => algorithm), original_value_dup
+    end
+    
+    define_method "test_string_decrypt!_on_a_string_with_the_#{algorithm}_algorithm_with_iv" do
+      encrypted_value_with_iv_dup = encrypted_value_with_iv.dup
+      encrypted_value_with_iv_dup.decrypt!(:key => key, :iv => iv, :algorithm => algorithm)
+      assert_equal original_value, encrypted_value_with_iv_dup
+    end
+    
+    define_method "test_string_decrypt!_on_a_string_with_the_#{algorithm}_algorithm_without_iv" do
+      encrypted_value_without_iv_dup = encrypted_value_without_iv.dup
+      encrypted_value_without_iv_dup.decrypt!(:key => key, :algorithm => algorithm)
+      assert_equal original_value, encrypted_value_without_iv_dup
     end
-  end
-  
-  define_method 'test_should_have_a_default_algorithm' do
-    assert algorithms.include?(Encryptor.default_options[:algorithm])
   end
   
   define_method 'test_should_use_the_default_algorithm_if_one_is_not_specified' do
     assert_equal Encryptor.encrypt(:value => original_value, :key => key, :algorithm => Encryptor.default_options[:algorithm]), Encryptor.encrypt(:value => original_value, :key => key)
   end
   
-  def test_should_be_able_to_change_the_default_algorithm
-    original_algorithm = Encryptor.default_options[:algorithm]
-    assert_not_equal 'test', original_algorithm
-    Encryptor.default_options[:algorithm] = 'test'
-    assert_equal 'test', Encryptor.default_options[:algorithm]
-    Encryptor.default_options[:algorithm] = original_algorithm
+  def test_should_have_a_default_algorithm
+    assert !Encryptor.default_options[:algorithm].nil?
+    assert !Encryptor.default_options[:algorithm].empty?
   end
   
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: encryptor
 version: !ruby/object:Gem::Version 
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors: 
 - Sean Huber
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-28 00:00:00 -08:00
+date: 2010-01-29 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -23,6 +23,7 @@ extra_rdoc_files: []
 
 files: 
 - lib/encryptor.rb
+- lib/encryptor/string.rb
 - MIT-LICENSE
 - Rakefile
 - README.rdoc