simply-aes 0.1.0

data/.githooks/pre-commit/run-ruby-appraiser

@@ -0,0 +1,23 @@
+#!/bin/bash
+if [ "$1" == '--about' ]; then
+  echo 'Validates staged changes with ruby-appraiser'
+  exit 0
+fi
+
+echo -e "\033[0;36mRuby Appraiser: running\033[0m"
+bundle exec ruby-appraiser rubocop --mode=staged
+result_code=$?
+if [ $result_code -gt "0" ]; then
+  echo -en "\033[0;31m" # RED
+  echo "[✘] Ruby Appraiser found newly-created defects and "
+  echo "    has blocked your commit."
+  echo "    Fix the defects and commit again."
+  echo "    To bypass, commit again with --no-verify."
+  echo -en "\033[0m" # RESET
+  exit $result_code
+else
+  echo -en "\033[0;32m" # GREEN
+  echo "[✔] Ruby Appraiser ok"
+  echo -en "\033[0m" #RESET
+fi
+exit

data/.githooks/pre-commit/run-specs

@@ -0,0 +1,21 @@
+#!/bin/bash
+if [ "$1" == '--about' ]; then
+  echo 'Runs project specs'
+  exit 0
+fi
+
+echo -e "\033[0;36mPre-commit hook: running specs...\033[0m"
+bundle exec rake spec
+result_code=$?
+if [ $result_code -gt "0" ]; then
+  echo -en "\033[0;31m" # RED
+  echo "[✘] Specs have failed and blocked your commit."
+  echo "    Fix the defects and try again."
+  echo "    To bypass, commit again with --no-verify."
+  echo -en "\033[0m" # RESET
+  exit $result_code
+else
+  echo -en "\033[0;32m" # GREEN
+  echo "[✔] Specs ok"
+  echo -en "\033[0m" #RESET
+fi

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rubocop.yml

@@ -0,0 +1,11 @@
+Style/Encoding:
+  Exclude:
+    - spec/simply-aes/format_spec.rb
+    - spec/simply-aes/cipher_spec.rb
+Style/FileName:
+  Exclude:
+    - lib/simply-aes.rb
+Metrics/CyclomaticComplexity:
+  Severity: warning
+Metrics/AbcSize:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+language: ruby
+script: "bundle exec rake spec"
+rvm:
+- 2.1.0
+- 2.0.0
+- 1.9.3

data/CONTRIBUTING.md

@@ -0,0 +1,31 @@
+# Contributing
+
+`SimplyAES` is [Apache-2-liennsed](LICENSE.md) and community contributions are welcome.
+
+## Git-Flow
+
+`SimplyAES` follows the [git-flow][] branching model, which means that every commit on `master` is a release.
+The default working branch is `develop`, so in general please keep feature pull-requests based against the current `develop`.
+Hotfixes -- fixes to already-released builds -- should be based on `master` or the appropriate major version's maintenance branch.
+
+ - ensure your issue is not already addressed in an issue or pull-request
+ - fork simply-aes
+ - use the git-flow model to start your feature or hotfix
+ - make some commits (please include specs)
+ - submit a pull-request
+
+## Bug Reporting
+
+Please include clear steps-to-reproduce.
+Spec files are especially welcome; a failing spec can be contributed as a pull-request against `develop`.
+
+## Ruby Appraiser
+
+`SimplyAES` uses the [ruby-appraiser][] gem via [pre-commit][] hook, which can be activated by installing [icefox/git-hooks][] and running `git-hooks --install` while in the repo.
+Rubocop supplies strong guidelines;
+use them to reduce defects as much as you can, but if you believe clarity will be sacrificed they can be bypassed with the `--no-verify` flag.
+
+[git-flow]: http://nvie.com/posts/a-successful-git-branching-model/
+[pre-commit]: .githooks/pre-commit/run-ruby-appraiser
+[ruby-appraiser]: https://github.com/simplymeasured/ruby-appraiser
+[icefox/git-hooks]: https://github.com/icefox/git-hooks

data/Gemfile

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

data/LICENSE.md

@@ -0,0 +1,13 @@
+Copyright 2013 Simply Measured
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,106 @@
+Simply AES
+==========
+
+Proper cryptography is easy to get wrong, and the Ruby stdlib adapters to OpenSSL's implentations of various encryption algorithms are often cumbersome to work with, expecting the developer to understand a great deal of terminology.
+
+SimplyAES provides a simple, straight-forward interface for securely encrypting data in Ruby using key-based AES-256, the most secure variant of the [*Advanced Encryption Standard*][AES], complete with securely-generated initialisation vectors.
+
+[AES]: http://en.wikipedia.org/wiki/Advanced_Encryption_Standard
+
+Installation
+------------
+
+SimplyAES is available on rubygems.org:
+
+    `gem install simply-aes`
+
+Basic Usage
+-----------
+
+~~~ ruby
+require 'simply-aes'
+
+# Create a Cipher object; unless provided,
+# a secure-random key will be generated.
+cipher = SimplyAES.new # => <SimplyAES::Cipher:70293125591140>
+
+# By default, the Cipher uses the Bytes formatter,
+# so byte data is emitted as a string of raw bytes.
+cipher.key # => "\x91\xD4\xEA=-\xC1\xB6\xE3\xDBP&\xDC\xB6\xFE\xDA\xF1\xF0L\x8Fz\e\xF7k]\x15\x9A\x9B8\xB1\xF3\xE3\xEE"
+
+# All public methods take a `:format` option,
+# which can be used to provide a format-helper;
+# let's use `hex` which is easier to work with:
+cipher.key(format: :hex) # => "91d4ea3d2dc1b6e3db5026dcb6fedaf1f04c8f7a1bf76b5d159a9b38b1f3e3ee"
+
+# We can encrypt strings very easily:
+secret = cipher.dump('Hello, World!', format: :hex) # => "521735c29ca1a6ae1a8fca49a9fb28ed8bf5d1bce3b39eb0286ea9c6b5dc286f"
+
+# We can also decrypt strings; here,
+# the format argument tells us how
+# the ciphertext is formatted:
+cipher.load(secret, format: :hex) # => 'Hello, World!'
+
+# Attempting to load a ciphertext with an incorrect key emits an exception:
+SimplyAES.new.load(secret, format: :hex) # !> SimplyAES::Cipher::LoadError
+~~~
+
+Interoperability
+----------------
+
+The ciphertext from SimplyAES can be decrypted easily by _any_ AES-compliant tool or library, with the following hints:
+
+In SimplyAES, a secure-random initialisation vector is generated for each encryption unless explicitly given, and the 16-byte IV is returned with the ciphertext;
+this means that two identical strings encrypted with the same key will have substantially different representations, making it harder for an attacker to correlate encrypted data.
+Because the IV does not need to be kept [secret][iv-requirements], SimplyAES emits the iv+ciphertext as a single byte string.
+
+~~~
++-------- 16-byte IV ----------++--- unbounded payload size --->
+|                              ||
+521735c29ca1a6ae1a8fca49a9fb28ed8bf5d1bce3b39eb0286ea9c6b5dc286f
+~~~
+
+To decrypt AES ciphertext that has been encrypted using another library, simply prepend the IV (in the same format as the encrypted data) to the ciphertext:
+
+~~~ ruby
+ciphertext = '8bf5d1bce3b39eb0286ea9c6b5dc286f'
+iv         = '521735c29ca1a6ae1a8fca49a9fb28ed'
+
+cipher.load(iv+ciphertext, format: :hex) # => 'Hello, World!'
+~~~
+
+To decrypt a SimplyAES iv+ciphertext payload, simply use the first 16 bytes as the IV, and the remaining as the ciphertext.
+
+~~~ ruby
+# encoding: BINARY
+key = "\x91\xD4\xEA=-\xC1\xB6\xE3\xDBP&\xDC\xB6\xFE\xDA\xF1\xF0L\x8Fz\e\xF7k]\x15\x9A\x9B8\xB1\xF3\xE3\xEE"
+
+payload = "R\x175\xC2\x9C\xA1\xA6\xAE\x1A\x8F\xCAI\xA9\xFB(\xED\x8B\xF5\xD1\xBC\xE3\xB3\x9E\xB0(n\xA9\xC6\xB5\xDC(o"
+iv = payload[0...16] # => "R\x175\xC2\x9C\xA1\xA6\xAE\x1A\x8F\xCAI\xA9\xFB(\xED"
+ciphertext = payload[16..-1] # => "\x8B\xF5\xD1\xBC\xE3\xB3\x9E\xB0(n\xA9\xC6\xB5\xDC(o"
+
+cipher = OpenSSL::Cipher.new('AES-256-CBC')
+cipher.decrypt
+cipher.key = key
+cipher.iv = iv
+
+decrypted = (cipher.update(ciphertext) + cipher.final) # => 'Hello, World!'
+~~~
+
+Advanced Usage
+--------------
+
+~~~ ruby
+require 'simply-aes'
+
+# The Cipher can be initialized with a default formatter:
+cipher = SimplyAES.new(format: :base64)
+
+# All byte-data respects the default format, unless overridden.
+cipher.key # => "Okve+PUasFuqB7zONT3XgCz0adJN3a6gr58k+/rve1E="
+~~~
+
+License
+-------
+
+SimplyAES is Apache 2 Licensed.

data/Rakefile

@@ -0,0 +1,3 @@
+# encoding: utf-8
+
+require 'bundler/gem_tasks'

data/lib/simply-aes.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'simply-aes/version'
+require 'simply-aes/cipher'
+
+# SimplyAES provides a simple, straight-forward interface for securely
+# encrypting data in Ruby using key-based AES-256, the most secure variant of
+# the [*Advanced Encryption Standard*][AES], complete with securely-generated
+# initialisation vectors.
+module SimplyAES
+  # @see SimplyAES::Cipher#initialize
+  def self.new(*args)
+    Cipher.new(*args)
+  end
+end

data/lib/simply-aes/cipher.rb

@@ -0,0 +1,122 @@
+# encoding: utf-8
+
+require 'simply-aes/format'
+require 'simply-aes/cipher/error'
+
+require 'openssl'
+
+module SimplyAES
+  # The Cipher is the heart of SimplyAES, and can be used to load ciphertext or
+  # to dump a string's ciphertext with a given key or a securely-generated one.
+  class Cipher
+    # @overload initialize(options)
+    # @overload initialize(key, options)
+    #   @param key [String] a 32-byte (256-bit) string
+    #     If not provided, a secure random key will be generated
+    #   @param options [Hash{Symbol=>Object}]
+    #   @option options [Symbol, SimplyAES::Format] (:bytes)
+    #     The format is used to load provided data, including the given key,
+    #     and as a default encoder/decoder of encrypted data; this can be
+    #     overridden in the #load and #dump methods.
+    #   @raise [SimplyAES::Cipher::Error]
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def initialize(*args)
+      options = (args.last.is_a?(Hash) ? args.pop.dup : {})
+
+      @format = Format[options.delete(:format) { :bytes }]
+
+      # extract the given key, or securely generate one
+      @key   = format.load(args.pop) unless args.empty?
+      @key ||= native_cipher.random_key
+
+      # validate initialisation
+      fail(ArgumentError, 'invalid key length') unless @key.bytesize == 32
+      fail(ArgumentError, 'wrong number of arguments') unless args.empty?
+      fail(ArgumentError, "unknown options: #{options}") unless options.empty?
+    rescue => err
+      raise Error, "failed to initialize #{self.class.name} (#{err})"
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    # @param options [Hash{Symbol=>Object}]
+    # @option options [Symbol] :format (default: self.format)
+    # @return [String] formatted string
+    def key(options = {})
+      format(options).dump(@key.dup)
+    end
+
+    # @param plaintext [String]
+    # @param options [Hash{Symbol=>Object}]
+    # @option options [String] :iv (default: secure random iv)
+    #   up to 16 bytes, used as an initialisation vector
+    # @option options [Symbol] :format (default: self.format)
+    # @return iv_ciphertext [String] binary string
+    # @raise SimplyAES::Cipher::DumpError
+    def dump(plaintext, options = {})
+      encipher = native_cipher(:encrypt)
+
+      # ensure a 16-byte initialisation vector
+      iv = options.fetch(:iv) { encipher.random_iv }
+      fail(ArgumentError, 'iv must be 16 bytes') unless iv.bytesize == 16
+      encipher.iv = iv
+
+      ciphertext = encipher.update(plaintext) + encipher.final
+
+      format(options).dump(iv + ciphertext)
+    rescue => err
+      raise DumpError, err.message
+    end
+    alias_method(:encrypt, :dump)
+
+    # @param iv_ciphertext [String]
+    # @option options [Symbol] :format (default: self.format)
+    # @return plaintext [String]
+    # @raise SimplyAES::Cipher::LoadError
+    def load(iv_ciphertext, options = {})
+      @key || fail(ArgumentError, 'key not provided!')
+
+      # if the IV is given as an argument, inject it to the ciphertext
+      given_iv = options[:iv]
+      given_iv && (iv_ciphertext = given_iv + iv_ciphertext)
+
+      # shift the 16-byte initialisation vector from the front
+      iv, ciphertext = format(options).load(iv_ciphertext).unpack('a16a*')
+
+      decipher = native_cipher(:decrypt)
+      decipher.iv = iv
+
+      decipher.update(ciphertext) + decipher.final
+    rescue => err
+      raise LoadError, err.message
+    end
+    alias_method(:decrypt, :load)
+
+    # @api private
+    # @return [String]
+    def inspect
+      "<#{self.class.name}:#{__id__}>"
+    end
+
+    # @api private
+    # @return [SimplyAES::Format]
+    def format(options = {})
+      Format[options.fetch(:format) { @format }]
+    end
+
+    private
+
+    # Returns an AES-256-CBC OpenSSL::Cipher object pre-configured with the
+    # requested mode and our key; used internally in initialize, load,
+    # and dump.
+    #
+    # @api private
+    # @param mode [:encode, :decode]
+    # @return [OpenSSL::Cipher]
+    def native_cipher(mode = nil)
+      ::OpenSSL::Cipher.new('AES-256-CBC').tap do |cipher|
+        mode && cipher.public_send(mode)
+        @key && cipher.key = @key
+      end
+    end
+  end
+end

data/lib/simply-aes/cipher/error.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module SimplyAES
+  # @see SimplyAES::Cipher
+  class Cipher
+    # SimplyAES::Cipher::Error is a wrapper for all
+    # errors raised by SimplyAES::Cipher
+    class Error < RuntimeError
+      # Back-port Ruby 2.1's Exception#cause
+      unless method_defined?(:cause)
+        def initialize(*args)
+          @cause = $! # rubocop:disable Style/SpecialGlobalVars
+          super
+        end
+        attr_reader :cause
+      end
+    end
+
+    LoadError = Class.new(Error)
+    DumpError = Class.new(Error)
+  end
+end

data/lib/simply-aes/format.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+# rubocop:disable Style/ModuleFunction
+
+module SimplyAES
+  # Implementations of SimplyAES::Format are formatting helpers,
+  # used by SimplyAES::Cipher to dump byte-strings and to load
+  # formatted byte-strings.
+  module Format
+    # @param  formatted  [String]
+    # @return bytestring [String]
+    def load(formatted)
+      return super if defined?(super)
+      fail(NotImplementedError)
+    end
+
+    # @param  bytestring [String]
+    # @return formatted  [String]
+    def dump(bytestring)
+      return super if defined?(super)
+      fail(NotImplementedError)
+    end
+
+    @implementations = {}
+
+    def self.included(implementation)
+      if (name = implementation.name)
+        # @todo support alternate-paths
+        short_name = name.split('::').last.downcase.to_sym
+        self[short_name] = implementation
+      end
+    end
+
+    def self.[]=(name, implementation)
+      fail(ArgumentError, "not a #{self}") unless implementation <= self
+      @implementations[name] = implementation
+    end
+
+    def self.[](name)
+      return name if name.is_a?(Module) && name <= self
+
+      @implementations.fetch(name) do
+        fail(ArgumentError, "Unknown format: #{name}")
+      end
+    end
+
+    # A Base64 implementation of SimplyAES::Format that emits
+    # strings *without* newlines and can handle concatenated-b64 strings
+    module Base64
+      extend self
+      require 'base64'
+      include Format
+
+      def load(formatted)
+        # Because Base64 has 3:4 raw:formated ratio, it doesn't always break
+        # cleanly on byte boundaries; add support for concatenated
+        # iv+ciphertext encoded payloads
+        formatted.scan(/[^=]+(?:=+|\Z)/m).map do |chunk|
+          ::Base64.decode64(chunk)
+        end.join
+      end
+
+      def dump(bytestring)
+        ::Base64.encode64(bytestring).tr("\n", '')
+      end
+    end
+
+    # A Hex implementation of SimplyAES::Format that emits
+    # strings *without* newlines and can handle concatenated-hex strings
+    module Hex
+      extend self
+      include Format
+
+      def load(formatted)
+        [formatted].pack('H*')
+      end
+
+      def dump(bytestring)
+        bytestring.unpack('H*')[0]
+      end
+    end
+
+    # The default implementation of SimplyAES::Format that reads and emits
+    # unformatted byte strings.
+    module Bytes
+      extend self
+      include Format
+
+      def load(formatted)
+        formatted.dup
+      end
+
+      def dump(bytestring)
+        bytestring.dup
+      end
+    end
+  end
+end

data/lib/simply-aes/version.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+# SimplyAES follows [semver](http://semver.org/).
+module SimplyAES
+  VERSION = '0.1.0'
+end

data/simply-aes.gemspec

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'simply-aes/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'simply-aes'
+  spec.version       = SimplyAES::VERSION
+  spec.authors       = ['Ryan Biesemeyer']
+  spec.email         = ['ryan@simplymeasured.com']
+  spec.summary       = 'Simple AES-256-driven encryption'
+  spec.homepage      = 'https://github.com/simplymeasured/simply-aes'
+  spec.license       = 'Apache 2'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'ruby-appraiser-rubocop'
+end

data/spec/simply-aes/cipher_spec.rb

@@ -0,0 +1,101 @@
+# encoding: BINARY (prevent string literals from being trans-coded to UTF-8)
+
+require 'simply-aes/cipher'
+
+describe(SimplyAES::Cipher) do
+  # default keys
+  let(:key_hex) do
+    'c3e6e6bbca5846ba4c1a4dd1953ccdc8a4e3fb0bfde7df8673de4f4f920e8df2'
+  end
+  let(:key) { SimplyAES::Format::Hex.load(key_hex) }
+
+  context '#key' do
+    context 'when initialised with a key' do
+      let(:cipher) { described_class.new(key_hex, format: :hex) }
+
+      subject { cipher }
+
+      it 'returns that key' do
+        expect(cipher.key).to eq(key_hex)
+      end
+      context('when a format is given') do
+        it 'formats the key' do
+          expect(cipher.key(format: :bytes)).to eq(key)
+        end
+      end
+    end
+
+    context 'when initialised without a key' do
+      let(:cipher) { described_class.new(format: :hex) }
+      it 'returns a securely-generated key' do
+        expect(cipher.key).to match(/[0-9a-f]{64}/)
+      end
+      it 'memoizes the securely-generated key' do
+        expect(cipher.key).to eq(cipher.key)
+      end
+    end
+  end
+
+  context '#dump' do
+    let(:cipher) { described_class.new(key_hex, format: :hex) }
+
+    # in order to make the output predictable, we need to use our own IV
+    context 'when an initialisation vector is given' do
+      let(:iv_hex) { 'babad50bea6035da71e9a0e076076860' }
+      let(:iv) { SimplyAES::Format::Hex.load(iv_hex) }
+      let(:decrypted) { 'Hello, World!' }
+      let(:result) { cipher.dump(decrypted, iv: iv, format: :bytes) }
+
+      context 'the encrypted value' do
+        subject { result }
+        it 'is prefixed by the IV' do
+          expect(result).to start_with(iv)
+        end
+        it 'is longer than the IV' do
+          expect(result.size).to be > (iv.size)
+        end
+        it 'matches the known value for the given key/iv pair' do
+          expect(result).to eq(
+            "\xBA\xBA\xD5\v\xEA`5\xDAq\xE9\xA0\xE0v\ah`\xE8\xCB\xF7+q\xB6" \
+            "\xA5\xF5\xCC\xAD\xB7\xEB\xA8\xB5s\xCD")
+        end
+      end
+    end
+
+    context 'dumping the same value multiple times' do
+      let(:decrypted) { 'Hello, World!' }
+
+      it 'emits different results, with different IVs' do
+        first  = cipher.dump(decrypted, format: :bytes)
+        second = cipher.dump(decrypted, format: :bytes)
+
+        # @todo: better quantify "different"
+        expect(first).to_not eq(second)
+      end
+    end
+  end
+
+  context '#load' do
+    let(:cipher) { described_class.new(key_hex, format: :hex) }
+    let(:decrypted) { 'Hello, World!' }
+    let(:encrypted) do
+      "\xBA\xBA\xD5\v\xEA`5\xDAq\xE9\xA0\xE0v\ah`\xE8\xCB\xF7+q\xB6" \
+      "\xA5\xF5\xCC\xAD\xB7\xEB\xA8\xB5s\xCD"
+    end
+
+    context 'when given a value that had been encrypted with the same key' do
+      it 'decrypts the value' do
+        expect(cipher.load(encrypted, format: :bytes)).to eq(decrypted)
+      end
+    end
+    context 'when given a value that was NOT encrypted with the same key' do
+      let(:alternate_cipher) { SimplyAES::Cipher.new(format: :bytes) }
+      let(:alternate_encrypted) { alternate_cipher.dump(decrypted) }
+      it 'raises a SimplyAES::Cipher::LoadError' do
+        expect do
+          cipher.load(alternate_encrypted, format: :bytes)
+        end.to raise_exception(SimplyAES::Cipher::LoadError)
+      end
+    end
+  end
+end

data/spec/simply-aes/format_spec.rb

@@ -0,0 +1,52 @@
+# encoding: BINARY (prevent string literals from being trans-coded to UTF-8)
+
+require 'simply-aes/format'
+
+shared_examples_for(SimplyAES::Format) do
+  let(:format) { described_class } # e.g., described_module
+  subject { format }
+  it { is_expected.to respond_to :load }
+  it { is_expected.to respond_to :dump }
+
+  context '#load' do
+    it 'loads the value' do
+      expect(format.load(formatted)).to eq(bytestring)
+    end
+  end
+
+  context '#dump' do
+    it 'dumps the value' do
+      expect(format.dump(bytestring)).to eq(formatted)
+    end
+  end
+
+  context 'implementation selecting' do
+    it 'can be loaded by name' do
+      expect(SimplyAES::Format[short_name]).to eq format
+    end
+    it 'can be loaded when given explicitly' do
+      expect(SimplyAES::Format[format]).to eq format
+    end
+  end
+end
+
+describe(SimplyAES::Format::Bytes) do
+  let(:formatted) { "\xff\x1c\xae" }
+  let(:bytestring) { "\xff\x1c\xae" }
+  let(:short_name) { :bytes }
+  it_should_behave_like(SimplyAES::Format)
+end
+
+describe(SimplyAES::Format::Base64) do
+  let(:formatted) { '/xyu' }
+  let(:bytestring) { "\xFF\x1C\xAE" }
+  let(:short_name) { :base64 }
+  it_should_behave_like(SimplyAES::Format)
+end
+
+describe(SimplyAES::Format::Hex) do
+  let(:formatted) { 'ff1cae' }
+  let(:bytestring) { "\xFF\x1C\xAE" }
+  let(:short_name) { :hex }
+  it_should_behave_like(SimplyAES::Format)
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: simply-aes
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Ryan Biesemeyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: ruby-appraiser-rubocop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- ryan@simplymeasured.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .githooks/pre-commit/run-ruby-appraiser
+- .githooks/pre-commit/run-specs
+- .gitignore
+- .rubocop.yml
+- .travis.yml
+- CONTRIBUTING.md
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/simply-aes.rb
+- lib/simply-aes/cipher.rb
+- lib/simply-aes/cipher/error.rb
+- lib/simply-aes/format.rb
+- lib/simply-aes/version.rb
+- simply-aes.gemspec
+- spec/simply-aes/cipher_spec.rb
+- spec/simply-aes/format_spec.rb
+homepage: https://github.com/simplymeasured/simply-aes
+licenses:
+- Apache 2
+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.23
+signing_key: 
+specification_version: 3
+summary: Simple AES-256-driven encryption
+test_files:
+- spec/simply-aes/cipher_spec.rb
+- spec/simply-aes/format_spec.rb
+has_rdoc: