ey-hmac 0.0.2

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.rspec

data/Gemfile

@@ -0,0 +1,22 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ey-hmac.gemspec
+gemspec
+
+group(:test) do
+  gem 'rb-fsevent'
+  gem 'guard-bundler'
+  gem 'guard-rspec'
+  gem 'pry-nav'
+end
+
+group(:rack) do
+  gem 'rack'
+  gem 'rack-test'
+  gem 'rack-client'
+end
+
+group(:faraday) do
+  gem 'faraday'
+  gem 'faraday_middleware'
+end

data/Guardfile

@@ -0,0 +1,7 @@
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^spec/(shared|support)/.*\.rb$}) { "spec" }
+  watch(%r{^lib/(.+)\.rb$})     { "spec" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Josh Lane & Jason Hansen
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,81 @@
+# Ey::Hmac
+
+Lightweight libraries and middlewares to perform HMAC signing and verification
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ey-hmac'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ey-hmac
+
+## Documentation
+
+  [rdoc.info](http://rubydoc.info/gems/ey-hmac)
+
+## Usage
+
+## Client Middleware
+
+### Rack
+
+Using ```Rack::Client```
+
+```ruby
+client = Rack::Client.new do
+  use Ey::Hmac::Rack, key_id, key_secret
+  run app
+end
+```
+
+### Faraday
+
+```ruby
+require 'ey-hmac/faraday'
+
+connection = Faraday.new do |c|
+  c.request :hmac, key_id, key_secret
+  c.adapter(:rack, app)
+end
+```
+
+## Server
+
+### Rack
+
+```ruby
+app = lambda do |env|
+  authenticated = Ey::Hmac.authenticated?(env, adapter: Ey::Hmac::Adapter::Rack) do |auth_id|
+    (auth_id == key_id) && key_secret
+  end
+  [(authenticated ? 200 : 401), {"Content-Type" => "text/plain"}, []]
+end
+
+```
+
+### Rails
+
+```ruby
+Ey::Hmac.authenticated?(request.env) do |auth_id|
+  if consumer_credential = ConsumerCredential.where(deleted_at: nil, auth_id: auth_id).first
+    consumer = consumer_credential.try(:consumer)
+    consumer && consumer.enabled && consumer_credential.auth_key
+  end
+end && consumer
+```
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/ey-hmac.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ey-hmac/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "ey-hmac"
+  gem.version       = Ey::Hmac::VERSION
+  gem.authors       = ["Josh Lane & Jason Hansen"]
+  gem.email         = ["jlane@engineyard.com"]
+  gem.description   = %q{Lightweight HMAC signing libraries and middleware for Farday and Rack}
+  gem.summary       = %q{Lightweight HMAC signing libraries and middleware for Farday and Rack}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/lib/ey-hmac/adapter/faraday.rb

@@ -0,0 +1,43 @@
+class Ey::Hmac::Adapter::Faraday < Ey::Hmac::Adapter
+  def method
+    request[:method].to_s.upcase
+  end
+
+  def content_type
+    %w[CONTENT-TYPE CONTENT_TYPE Content-Type Content_Type].inject(nil){|r, h| r || request[h]}
+  end
+
+  def content_digest
+    existing = %w[CONTENT-DIGEST CONTENT_DIGEST Content-Digest Content_Digest].inject(nil){|r,h| r || request[:request_headers][h]}
+    existing || (request[:request_headers]['Content-Digest'] = (body && Digest::MD5.hexdigest(body)))
+  end
+  
+  def body
+    if request[:body] && request[:body].to_s != ""
+      request[:body]
+    else nil
+    end
+  end
+
+  def date
+    existing = %w[DATE Date].inject(nil){|r,h| r || request[h]}
+    existing || (request[:request_headers]['Date'] = Time.now.httpdate)
+  end
+
+  def path
+    request[:url].path
+  end
+
+  def sign!(key_id, key_secret)
+    %w[CONTENT-TYPE CONTENT_TYPE Content-Type Content_Type].inject(nil){|r,h| request[:request_headers][h]}
+    if options[:version]
+      request[:request_headers]['X-Signature-Version'] = options[:version]
+    end
+
+    request[:request_headers][authorization_header] = authorization(key_id, key_secret)
+  end
+
+  def authorization_signature
+    %w[Authorization AUTHORIZATION].inject(nil){|r, h| r || request[:request_headers][h]}
+  end
+end

data/lib/ey-hmac/adapter/rack.rb

@@ -0,0 +1,50 @@
+require 'rack'
+
+class Ey::Hmac::Adapter::Rack < Ey::Hmac::Adapter
+  def initialize(request, options)
+    super
+    @request = ::Rack::Request.new(request) if request.is_a?(Hash)
+  end
+
+  def method
+    request.request_method.to_s.upcase
+  end
+
+  def content_type
+    request.content_type
+  end
+
+  def content_digest
+    request.env['HTTP_CONTENT_DIGEST'] ||= body && Digest::MD5.hexdigest(body)
+  end
+  
+  def body
+    if request.env["rack.input"]
+      request.env["rack.input"].rewind
+      body = request.env["rack.input"].read
+      request.env["rack.input"].rewind
+      body == "" ? nil : body
+    else nil
+    end
+  end
+
+  def date
+    request.env['HTTP_DATE'] ||= Time.now.httpdate
+  end
+
+  def path
+    request.path
+  end
+
+  def sign!(key_id, key_secret)
+    if options[:version]
+      request.env['HTTP_X_SIGNATURE_VERSION'] = options[:version]
+    end
+
+    request.env["HTTP_#{authorization_header.to_s.upcase}"] = authorization(key_id, key_secret)
+  end
+
+  def authorization_signature
+    request.env["HTTP_#{authorization_header.to_s.upcase}"]
+  end
+end

data/lib/ey-hmac/adapter.rb

@@ -0,0 +1,127 @@
+# This class is responsible for forming the canonical string to used to sign requests
+# @abstract override methods {#method}, {#path}, {#body}, {#content_type} and {#content_digest}
+class Ey::Hmac::Adapter
+  AUTHORIZATION_REGEXP = /\w+ ([^:]+):(.+)$/
+
+  autoload :Rack, "ey-hmac/adapter/rack"
+  autoload :Faraday, "ey-hmac/adapter/faraday"
+
+  attr_reader :request, :options, :authorization_header, :service
+
+  # @param [Object] request signer-specific request implementation
+  # @option options [Integer] :version signature version
+  # @option options [String] :authorization_header ('Authorization') Authorization header key.
+  # @option options [String] :server ('EyHmac') service name prefixed to {#authorization}. set to {#service}
+  def initialize(request, options={})
+    @request, @options = request, options
+
+    @authorization_header = options[:authorization_header] || 'Authorization'
+    @service = options[:service] || 'EyHmac'
+  end
+
+  # In order for the server to correctly authorize the request, the client and server MUST AGREE on this format
+  #
+  # default canonical string formation is '{#method}\\n{#content_type}\\n{#content_digest}\\n{#date}\\n{#path}'
+  # @return [String] canonical string used to form the {#signature}
+  def canonicalize
+    [method, content_type, content_digest, date, path].join("\n")
+  end
+
+  # @param [String] key_secret private HMAC key
+  # @return [String] HMAC signature of {#request}
+  # @todo handle multiple hash functions
+  def signature(key_secret)
+    Base64.encode64(OpenSSL::HMAC.digest(OpenSSL::Digest::Digest.new('sha1'), key_secret, canonicalize)).strip
+  end
+
+  # @param [String] key_id public HMAC key
+  # @param [String] key_secret private HMAC key
+  # @return [String] HMAC header value of {#request}
+  def authorization(key_id, key_secret)
+    "#{service} #{key_id}:#{signature(key_secret)}"
+  end
+
+  # @abstract
+  # @return [String] upcased request verb. i.e. 'GET'
+  def method
+    raise NotImplementedError
+  end
+
+  # @abstract
+  # @return [String] request path. i.e. '/blogs/1'
+  def path
+    raise NotImplementedError
+  end
+
+  # @abstract
+  # Digest of body. Default is MD5.
+  # @todo support explicit digest methods
+  # @return [String] digest of body
+  def content_digest
+    raise NotImplementedError
+  end
+
+  # @abstract
+  # @return [String] request body.
+  # @return [NilClass] if there is no body or the body is empty
+  def body
+    raise NotImplementedError
+  end
+
+  # @abstract
+  # @return [String] value of the Content-Type header in {#request}
+  def content_type
+    raise NotImplementedError
+  end
+
+  # @abstract
+  # @return [String] value of the Date header in {#request}.
+  # @see {Time#http_date}
+  def date
+    raise NotImplementedError
+  end
+
+  # @abstract used when verifying a signed request
+  # @return [String] value of the {#authorization_header}
+  def authorization_signature
+    raise NotImplementedError
+  end
+
+  # @abstract
+  # Add {#signature} header to request. Typically this is 'Authorization' or 'WWW-Authorization'
+  def sign!(key_id, key_secret)
+    raise NotImplementedError
+  end
+
+  # Check {#authorization_signature} against calculated {#signature}
+  # @yieldparam key_id [String] public HMAC key
+  # @return [Boolean] true if block yields matching private key and signature matches, else false
+  # @see {#authenticated!}
+  def authenticated?(&block)
+    authenticated!(&block)
+  rescue Ey::Hmac::Error
+    false
+  end
+
+  # Check {#authorization_signature} against calculated {#signature}
+  # @yieldparam key_id [String] public HMAC key
+  # @return [Boolean] true if block yields matching private key
+  # @raise [Ey::Hmac::Error] if authentication fails
+  def authenticated!(&block)
+    if authorization_match = AUTHORIZATION_REGEXP.match(authorization_signature)
+      key_id          = authorization_match[1]
+      signature_value = authorization_match[2]
+
+      if key_secret = block.call(key_id)
+        if signature_value == (calculated_signature = signature(key_secret))
+        else raise(Ey::Hmac::SignatureMismatch, "Calculated siganature #{signature_value} does not match #{calculated_signature} using #{canonicalize.inspect}")
+        end
+      else raise(Ey::Hmac::MissingSecret, "Failed to find secret matching #{key_id.inspect}")
+      end
+    else
+      raise(Ey::Hmac::MissingAuthorization, "Failed to parse authorization_signature #{authorization_signature}")
+    end
+    true
+  end
+  alias authenticate! authenticated!
+end

data/lib/ey-hmac/faraday.rb

@@ -0,0 +1,25 @@
+require 'faraday'
+
+if Faraday.respond_to? :register_middleware
+  Faraday.register_middleware(:request, {:hmac => lambda { Ey::Hmac::Faraday }})
+end
+
+# Request middleware that performs HMAC request signing
+class Ey::Hmac::Faraday < Faraday::Middleware
+  dependency do
+    require 'ey-hmac' unless defined?(Ey::Hmac)
+  end
+
+  attr_reader :key_id, :key_secret, :options
+
+  def initialize(app, key_id, key_secret, options = {})
+    super(app)
+    @key_id, @key_secret = key_id, key_secret
+    @options = options
+  end
+
+  def call(env)
+    Ey::Hmac.sign!(env, key_id, key_secret, {adapter: Ey::Hmac::Adapter::Faraday}.merge(options))
+    @app.call(env)
+  end
+end

data/lib/ey-hmac/rack.rb

@@ -0,0 +1,15 @@
+# Request middleware that performs HMAC request signing
+class Ey::Hmac::Rack
+  attr_reader :key_id, :key_secret, :options
+
+  def initialize(app, key_id, key_secret, options = {})
+    @app = app
+    @key_id, @key_secret = key_id, key_secret
+    @options = options
+  end
+
+  def call(env)
+    Ey::Hmac.sign!(env, key_id, key_secret, {adapter: Ey::Hmac::Adapter::Rack}.merge(options))
+    @app.call(env)
+  end
+end

data/lib/ey-hmac/version.rb

@@ -0,0 +1,5 @@
+module Ey
+  module Hmac
+    VERSION = "0.0.2"
+  end
+end

data/lib/ey-hmac.rb

@@ -0,0 +1,82 @@
+require "ey-hmac/version"
+
+require 'base64'
+require 'digest/md5'
+require 'openssl'
+
+module Ey
+  module Hmac
+    Error = Class.new(StandardError)
+
+    MissingSecret        = Class.new(Error)
+    MissingAuthorization = Class.new(Error)
+    SignatureMismatch    = Class.new(Error)
+
+    autoload :Adapter, "ey-hmac/adapter"
+    autoload :Faraday, "ey-hmac/faraday"
+    autoload :Rack, "ey-hmac/rack"
+
+    def self.default_adapter=(default_adapter)
+      @default_adapter = default_adapter
+    end
+
+    def self.default_adapter
+      @default_adapter ||= begin
+                             if defined?(Rack) || defined?(Rails)
+                               Ey::Hmac::Adapter::Rack
+                             elsif defined?(Faraday)
+                               Ey::Hmac::Adapter::Rails
+                             end
+                           end
+    end
+
+    # @example
+    #   Ey::Hmac.sign!(env, @key_id, @key_secret)
+    #
+    # @param request [Hash] request environment
+    # @option options [Ey::Hmac::Adapter] :adapter (#{default_adapter}) adapter to sign request with
+    # @option options [Integer] :version (nil) signature version
+    # @option options [String] :authorization_header ('Authorization') Authorization header key.
+    # @option options [String] :server ('EyHmac') service name prefixed to {#authorization}
+    # @see {Ey::Hmac::Adapter#sign!}
+    def self.sign!(request, key_id, key_secret, options={})
+      adapter = options[:adapter] || Ey::Hmac.default_adapter
+
+      raise ArgumentError, "Missing adapter and Ey::Hmac.default_adapter" unless adapter
+
+      adapter.new(request, options).sign!(key_id, key_secret)
+    end
+
+    # @example
+    #   Ey::Hmac.authenticated? do |key_id|
+    #     @consumer = Consumer.where(auth_id: key_id).first
+    #     @consumer && @consumer.auth_key
+    #   end
+    # @param request [Hash] request environment
+    # @option options [Ey::Hmac::Adapter] :adapter ({#default_adapter}) adapter to verify request with
+    # @see {Ey::Hmac::Adapter#authenticated?}
+    def self.authenticated?(request, options={}, &block)
+      adapter = options[:adapter] || Ey::Hmac.default_adapter
+
+      raise ArgumentError, "Missing adapter and Ey::Hmac.default_adapter" unless adapter
+
+      adapter.new(request, options).authenticated?(&block)
+    end
+
+    # @example
+    #   Ey::Hmac.authenticate! do |key_id|
+    #     @consumer = Consumer.where(auth_id: key_id).first
+    #     @consumer && @consumer.auth_key
+    #   end
+    # @param request [Hash] request environment
+    # @option options [Ey::Hmac::Adapter] :adapter ({#default_adapter}) adapter to verify request with
+    # @see {Ey::Hmac::Adapter#authenticate!}
+    def self.authenticate!(request, options={}, &block)
+      adapter = options[:adapter] || Ey::Hmac.default_adapter
+
+      raise ArgumentError, "Missing adapter and Ey::Hmac.default_adapter" unless adapter
+
+      adapter.new(request, options).authenticate!(&block)
+    end
+  end
+end

data/spec/faraday_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe "faraday" do
+  before(:all) { Bundler.require(:faraday) }
+  let!(:key_id)     { (0...8).map{ 65.+(rand(26)).chr}.join }
+  let!(:key_secret) { (0...16).map{ 65.+(rand(26)).chr}.join }
+
+  describe "adapter" do
+    let!(:adapter)    { Ey::Hmac::Adapter::Faraday }
+    let!(:request) do
+      Faraday::Request.new.tap do |r|
+        r.method = :get
+        r.path = "/auth"
+        r.body = "{1: 2}"
+        r.headers = {"Content-Type" => "application/xml"}
+      end.to_env(Faraday::Connection.new("http://localhost"))
+    end
+
+    it "should sign and read request" do
+      Ey::Hmac.sign!(request, key_id, key_secret, adapter: adapter)
+
+      request[:request_headers]['Authorization'].should start_with("EyHmac")
+      request[:request_headers]['Content-Digest'].should == Digest::MD5.hexdigest(request[:body])
+      Time.parse(request[:request_headers]['Date']).should_not be_nil
+
+      yielded = false
+
+      Ey::Hmac.authenticated?(request, adapter: adapter) do |key_id|
+        key_id.should == key_id
+        yielded = true
+        key_secret
+      end.should be_true
+
+      yielded.should be_true
+    end
+
+    include_examples "authentication"
+  end
+
+  describe "middleware" do
+    it "should sign request" do
+      require 'ey-hmac/faraday'
+      Bundler.require(:rack)
+
+      app = lambda do |env|
+        authenticated = Ey::Hmac.authenticated?(env, adapter: Ey::Hmac::Adapter::Rack) do |auth_id|
+          (auth_id == key_id) && key_secret
+        end
+        [(authenticated ? 200 : 401), {"Content-Type" => "text/plain"}, []]
+      end
+
+      request_env = nil
+      connection = Faraday.new do |c|
+        c.request :hmac, key_id, key_secret
+        c.adapter(:rack, app)
+      end
+
+      connection.get("/resources").status.should == 200
+    end
+  end
+end

data/spec/rack_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe "rack" do
+  before(:all) { Bundler.require(:rack) }
+
+  let!(:key_id)     { (0...8).map{ 65.+(rand(26)).chr}.join }
+  let!(:key_secret) { (0...16).map{ 65.+(rand(26)).chr}.join }
+
+  describe "adapter" do
+    let(:adapter)     { Ey::Hmac::Adapter::Rack }
+    let(:request)     {
+      Rack::Request.new({
+        "rack.input" => StringIO.new("{1: 2}"),
+        "HTTP_CONTENT_TYPE" => "application/json",
+      })
+    }
+
+    it "should sign and read request" do
+      Ey::Hmac.sign!(request, key_id, key_secret, adapter: adapter)
+
+      request.env['HTTP_AUTHORIZATION'].should start_with("EyHmac")
+      request.env['HTTP_CONTENT_DIGEST'].should == Digest::MD5.hexdigest(request.body.tap(&:rewind).read)
+      Time.parse(request.env['HTTP_DATE']).should_not be_nil
+
+      yielded = false
+
+      Ey::Hmac.authenticated?(request, adapter: adapter) do |key_id|
+        key_id.should == key_id
+        yielded = true
+        key_secret
+      end.should be_true
+
+      yielded.should be_true
+    end
+
+    include_examples "authentication"
+  end
+
+  describe "middleware" do
+    it "should sign and read request" do
+      app = lambda do |env|
+        authenticated = Ey::Hmac.authenticated?(env, adapter: Ey::Hmac::Adapter::Rack) do |auth_id|
+          (auth_id == key_id) && key_secret
+        end
+        [(authenticated ? 200 : 401), {"Content-Type" => "text/plain"}, []]
+      end
+
+      _key_id, _key_secret = key_id, key_secret
+      client = Rack::Client.new do
+        use Ey::Hmac::Rack, _key_id, _key_secret
+        run app
+      end
+
+      client.get("/resource").status.should == 200
+    end
+  end
+end

data/spec/shared/authenticated.rb

@@ -0,0 +1,55 @@
+shared_examples_for "authentication" do
+  describe "#authenticated?" do
+    it "should not authenticate invalid secret" do
+      Ey::Hmac.sign!(request, key_id, "#{key_secret}bad", adapter: adapter)
+
+      Ey::Hmac.authenticated?(request, adapter: adapter) do |auth_id|
+        (auth_id == key_id) && key_secret
+      end.should be_false
+    end
+
+    it "should not authenticate invalid id" do
+      Ey::Hmac.sign!(request, "what#{key_id}", key_secret, adapter: adapter)
+
+      Ey::Hmac.authenticated?(request, adapter: adapter) do |auth_id|
+        (auth_id == key_id) && key_secret
+      end.should be_false
+    end
+
+    it "should not authenticate missing header" do
+      Ey::Hmac.authenticated?(request, adapter: adapter) do |auth_id|
+        (auth_id == key_id) && key_secret
+      end.should be_false
+    end
+  end
+
+  describe "#authenticate!" do
+    it "should not authenticate invalid secret" do
+      Ey::Hmac.sign!(request, key_id, "#{key_secret}bad", adapter: adapter)
+
+      lambda {
+        Ey::Hmac.authenticate!(request, adapter: adapter) do |auth_id|
+          (auth_id == key_id) && key_secret
+        end
+      }.should raise_exception(Ey::Hmac::SignatureMismatch)
+    end
+
+    it "should not authenticate invalid id" do
+      Ey::Hmac.sign!(request, "what#{key_id}", key_secret, adapter: adapter)
+
+      lambda {
+        Ey::Hmac.authenticate!(request, adapter: adapter) do |auth_id|
+          (auth_id == key_id) && key_secret
+        end
+      }.should raise_exception(Ey::Hmac::MissingSecret)
+    end
+
+    it "should not authenticate missing header" do
+      lambda {
+        Ey::Hmac.authenticate!(request, adapter: adapter) do |auth_id|
+          (auth_id == key_id) && key_secret
+        end.should be_false
+      }.should raise_exception(Ey::Hmac::MissingAuthorization)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require File.expand_path("../../lib/ey-hmac", __FILE__)
+
+Bundler.require(:test)
+
+Dir[File.expand_path("../{support,shared}/*.rb", __FILE__)].each{|f| require(f)}
+
+RSpec.configure do |config|
+  config.order = "random"
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: ey-hmac
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Josh Lane & Jason Hansen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-05 00:00:00.000000000 Z
+dependencies: []
+description: Lightweight HMAC signing libraries and middleware for Farday and Rack
+email:
+- jlane@engineyard.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ey-hmac.gemspec
+- lib/ey-hmac.rb
+- lib/ey-hmac/adapter.rb
+- lib/ey-hmac/adapter/faraday.rb
+- lib/ey-hmac/adapter/rack.rb
+- lib/ey-hmac/faraday.rb
+- lib/ey-hmac/rack.rb
+- lib/ey-hmac/version.rb
+- spec/faraday_spec.rb
+- spec/rack_spec.rb
+- spec/shared/authenticated.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Lightweight HMAC signing libraries and middleware for Farday and Rack
+test_files:
+- spec/faraday_spec.rb
+- spec/rack_spec.rb
+- spec/shared/authenticated.rb
+- spec/spec_helper.rb
+has_rdoc: