aes 0.3.0 → 0.4.0

data/README.rdoc

@@ -1,28 +1,37 @@
 = aes
 
-An AES encrypt/decrypt gem built ontop of OpenSSL.  Not as quick as FastAES, but it doesn't require building native extensions and supports Base64 encoded input and output.
+An AES encrypt/decrypt gem built on top of OpenSSL.  Not as quick as FastAES but doesn't require building native extensions - also supports Base64 encoded input and output.
 
 Usage:
 
-require 'aes'
+ require 'aes'
 
-# Generate a random key
-key = AES.key(32)  
- => "290c3c5d812a4ba7ce33adf09598a462"
+ # Generate a random key
+ key = AES.key
+  => "290c3c5d812a4ba7ce33adf09598a462"
+  
+ # Encrypt a string.  Default output is base_64 encoded, init_vector and cipher_text are joined with "$"
+ b64 = AES.encrypt("A super secret message", key)
+  => "IJjbgbv/OvPIAf4R5qAWyg==$fy0v7JwRX4kyAWflgouQlt9XGmiDKvbQMRHmQ+vy1fA="
 
-# Encrypt something, default output is base_64 encoded.  init_vector and cipher_text are joined with "$"
-b64 = AES.encrypt(key, "A super secret message")
- => "IJjbgbv/OvPIAf4R5qAWyg==$fy0v7JwRX4kyAWflgouQlt9XGmiDKvbQMRHmQ+vy1fA="
+ # Same as above but minus the base64 encoding, init_vector and cipher_text are shoved into an array
+ plain = AES.encrypt("A super secret message", key, {:format => :plain}) #
+  => [";\202\222\306\376<\206\343\023\245\312\225\214KAm", 
+      "C\343\023\323U~W>\023y\217\341\201\371\352\334\311^\307\352{\020 H(DVw\3224N\223"]
 
-# Same as above but minus the base64 encoding, initialization vector and cipher_text are shoved into an array
-plain = AES.encrypt(key, "A super secret message", {:format => :plain}) #
- => [";\202\222\306\376<\206\343\023\245\312\225\214KAm", "C\343\023\323U~W>\023y\217\341\201\371\352\334\311^\307\352{\020 H(DVw\3224N\223"]
+ # Generate a random initialization vector
+ iv = AES.iv(:base_64)
+  => "IJjbgbv/OvPIAf4R5qAWyg=="
  
-AES.decrypt(key, b64)
- => "A super secret message"
+ # Encrypt a string, with a provided key and init_vector.  
+ b64_iv = AES.encrypt("A super secret message", key, {:iv => iv})
+  => "IJjbgbv/OvPIAf4R5qAWyg==$fy0v7JwRX4kyAWflgouQlt9XGmiDKvbQMRHmQ+vy1fA="
  
-AES.decrypt(key, plain, {:format => :plain})
-=> "A super secret message" 
+ AES.decrypt(b64, key)
+  => "A super secret message"
+ 
+ AES.decrypt(plain, key, {:format => :plain})
+  => "A super secret message" 
 
 == Contributing to aes
  

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.0

data/aes.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{aes}
-  s.version = "0.3.0"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Carl Hicks"]
-  s.date = %q{2010-12-05}
+  s.date = %q{2011-01-03}
   s.description = %q{An AES encrypt/decrypt gem built ontop of OpenSSL.  Not as quick as FastAES, but it doesn't require building
     native extensions and supports Base64 encoded input and output.}
   s.email = %q{carl.hicks@gmail.com}
@@ -26,6 +26,7 @@ Gem::Specification.new do |s|
     "VERSION",
     "aes.gemspec",
     "lib/aes.rb",
+    "lib/aes/aes.rb",
     "test/helper.rb",
     "test/test_aes.rb"
   ]

data/lib/aes.rb

@@ -1,130 +1,3 @@
 require 'openssl'
 require 'base64'
-
-class AES
-  class << self
-    # Encrypts the plain_text with the provided key
-    def encrypt(key, plain_text, opts={})
-      AES.new(key,opts).encrypt(plain_text)
-    end
-    # Decrypts the cipher_text with the provided key
-    def decrypt(key, cipher_text, opts={})
-      AES.new(key,opts).decrypt(cipher_text)
-    end
-    # Generates a random key of the specified length in bits
-    # Default output is 
-    def key(length=256,format=:plain)
-      key = AES.new("").random_key(256)
-      case format
-      when :base_64
-        Base64.encode64(key)
-      else
-        key
-      end
-    end
-  end
-
-  attr :options
-  attr :key
-  attr :cipher
-  attr :cipher_text
-  attr :plain_text
-  
-  def initialize(key, opts={})
-    merge_options opts
-    @key = key
-    self
-  end
-  
-  # Encrypts
-  def encrypt(plain_text)
-    @plain_text = plain_text
-    _setup(:encrypt)
-    case @options[:format]
-    when :base_64
-      @cipher_text = b64_e(_iv) << "$" << b64_e(_encrypt)
-    else
-      @cipher_text = [_iv, _encrypt]
-    end
-    @cipher_text
-  end
-
-  # Decrypts  
-  def decrypt(cipher_text)
-    @cipher_text = cipher_text
-    _setup(:decrypt)
-    case @options[:format]
-    when :base_64
-      ctext = b64_d(@cipher_text)
-    else
-      ctext = @cipher_text
-    end
-    @cipher.iv  = ctext[0]
-    @plain_text = @cipher.update(ctext[1]) + @cipher.final 
-  end
-
-  # Generate a random initialization vector
-  def random_iv
-    _setup(:encrypt)
-    _iv
-  end
-  
-  # Generate a random key
-  def random_key(length=256)
-    _random_seed.unpack('H*')[0][0..((length/8)-1)]
-    #Digest::SHA256.digest(_random_seed)[0..(length / 8)]
-  end
-  
-  private
-    
-    # Generates a random seed value
-    def _random_seed(size=32)
-      if defined? OpenSSL::Random
-        return OpenSSL::Random.random_bytes(size)
-      else
-        chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
-        (1..size).collect{|a| chars[rand(chars.size)] }.join        
-      end
-    end
-    
-    # Un-Base64's the IV and CipherText
-    # Returns an array containing the IV, and CipherText
-    def b64_d(data)
-      iv_ctext = []
-      data.split('$').each do |part|
-        iv_ctext << Base64.decode64(part)
-      end
-      iv_ctext
-    end
-  
-    # Base64 Encodes a string
-    def b64_e(data)
-      Base64.encode64(data).chomp
-    end
-  
-    # Generates and returns a random initialization vector
-    def _iv
-      @cipher.random_iv
-    end
-    
-    # Encrypts @plain_text
-    def _encrypt
-      @cipher.update(@plain_text) + @cipher.final
-    end
-
-    # Merge init options with defaults
-    def merge_options(opts)
-      @options = {
-        :format => :base_64,
-        :cipher => "AES-256-CBC"
-      }.merge! opts
-    end
-      
-    # Create a new cipher using the cipher type specified
-    def _setup(action)
-      @cipher = OpenSSL::Cipher::Cipher.new(@options[:cipher]) 
-      # Toggles encryption mode
-      @cipher.send(action)
-      @cipher.key = @key.unpack('a2'*32).map{|x| x.hex}.pack('c'*32)  
-    end
-end
+require 'aes/aes'

data/lib/aes/aes.rb

@@ -0,0 +1,150 @@
+module AES
+  class << self
+    # Encrypts the plain_text with the provided key
+    def encrypt(plain_text, key, opts={})
+      ::AES::AES.new(key, opts).encrypt(plain_text)
+    end
+    # Decrypts the cipher_text with the provided key
+    def decrypt(cipher_text, key, opts={})
+      ::AES::AES.new(key, opts).decrypt(cipher_text)
+    end
+    # Generates a random key of the specified length in bits
+    # Default format is :plain
+    def key(length=256,format=:plain)
+      key = ::AES::AES.new("").random_key(256)
+      case format
+      when :base_64
+        Base64.encode64(key).chomp
+      else
+        key
+      end
+    end
+    # Generates a random iv 
+    # Default format is :plain
+    def iv(format=:plain)
+      iv = ::AES::AES.new("").random_iv
+      case format
+      when :base_64
+        Base64.encode64(iv).chomp
+      else
+        iv
+      end      
+    end
+  end
+  
+  class AES
+    attr :options
+    attr :key
+    attr :iv
+    attr :cipher
+    attr :cipher_text
+    attr :plain_text
+  
+    def initialize(key, opts={})
+      merge_options opts
+      @cipher = nil
+      @key    = key
+      @iv   ||= random_iv
+      self
+    end
+  
+    # Encrypts
+    def encrypt(plain_text)
+      @plain_text = plain_text
+      _setup(:encrypt)
+      @cipher.iv  = @iv
+      case @options[:format]
+      when :base_64
+        @cipher_text = b64_e(@iv) << "$" << b64_e(_encrypt)
+      else
+        @cipher_text = [@iv, _encrypt]
+      end
+      @cipher_text
+    end
+
+    # Decrypts  
+    def decrypt(cipher_text)
+      @cipher_text = cipher_text
+      _setup(:decrypt)
+      case @options[:format]
+      when :base_64
+        ctext = b64_d(@cipher_text)
+      else
+        ctext = @cipher_text
+      end
+      @cipher.iv  = ctext[0]
+      @plain_text = @cipher.update(ctext[1]) + @cipher.final 
+    end
+
+    # Generate a random initialization vector
+    def random_iv
+      _setup(:encrypt)
+      @cipher.random_iv
+    end
+  
+    # Generate a random key
+    def random_key(length=256)
+      _random_seed.unpack('H*')[0][0..((length/8)-1)]
+    end
+  
+    private
+    
+      # Generates a random seed value
+      def _random_seed(size=32)
+        if defined? OpenSSL::Random
+          return OpenSSL::Random.random_bytes(size)
+        else
+          chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
+          (1..size).collect{|a| chars[rand(chars.size)] }.join        
+        end
+      end
+    
+      # Un-Base64's the IV and CipherText
+      # Returns an array containing the IV, and CipherText
+      def b64_d(data)
+        iv_and_ctext = []
+        data.split('$').each do |part|
+          iv_and_ctext << Base64.decode64(part)
+        end
+        iv_and_ctext
+      end
+  
+      # Base64 Encodes a string
+      def b64_e(data)
+        Base64.encode64(data).chomp
+      end
+  
+      # Encrypts @plain_text
+      def _encrypt
+        @cipher.update(@plain_text) + @cipher.final
+      end
+
+      # Merge init options with defaults
+      def merge_options(opts)
+        @options = {
+          :format => :base_64,
+          :cipher => "AES-256-CBC",
+          :iv     => nil,
+        }.merge! opts
+        _handle_iv
+      end
+      
+      def _handle_iv
+        @iv = @options[:iv]
+        return if @iv.nil?
+
+        case @options[:format]
+        when :base_64
+          @iv  = Base64.decode64(@options[:iv])
+        end
+      end
+      
+      # Create a new cipher using the cipher type specified
+      def _setup(action)
+        @cipher ||= OpenSSL::Cipher::Cipher.new(@options[:cipher]) 
+        # Toggles encryption mode
+        @cipher.send(action)
+        @cipher.key = @key.unpack('a2'*32).map{|x| x.hex}.pack('c'*32)
+      end
+  end
+end

data/test/test_aes.rb

@@ -5,15 +5,24 @@ class TestAES < Test::Unit::TestCase
   should "encrypt and decrypt a string" do
     key = "01234567890123456789012345678901"
     msg = "This is a message that nobody should ever see"
-    enc = AES.encrypt(key, msg)
-    assert_equal msg, AES.decrypt(key, enc)
-    enc = AES.encrypt(key, msg, {:format => :plain})
-    assert_equal msg, AES.decrypt(key, enc, {:format => :plain})
+    enc = AES.encrypt(msg, key)
+    assert_equal msg, AES.decrypt(enc, key)
+    enc = AES.encrypt(msg, key, {:format => :plain})
+    assert_equal msg, AES.decrypt(enc, key, {:format => :plain})
+  end
+  
+  should "produce the same encrypted string when provided an identical key and iv" do
+    key  = "01234567890123456789012345678901"
+    msg  = "This is a message that nobody should ever see"
+    iv   = AES.iv(:base_64)
+    enc1 = AES.encrypt(msg, key, {:iv => iv})
+    enc2 = AES.encrypt(msg, key, {:iv => iv})
+    assert_equal enc1, enc2
   end
   
   should "generate a new key when AES#key" do
     assert_equal 32, AES.key.length
-    assert_equal 45, AES.key(256, :base_64).length
+    assert_equal 44, AES.key(256, :base_64).length
   end
     
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: aes
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 3
+  - 4
   - 0
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Carl Hicks
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-05 00:00:00 -08:00
+date: 2011-01-03 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -98,6 +98,7 @@ files:
 - VERSION
 - aes.gemspec
 - lib/aes.rb
+- lib/aes/aes.rb
 - test/helper.rb
 - test/test_aes.rb
 has_rdoc: true