king_hmac 1.0.0

data/lib/king_hmac/rails/controller.rb

@@ -0,0 +1,63 @@
+# Integration with Rails
+#
+class Rails # :nodoc:
+  module ControllerFilter # :nodoc:
+    module ClassMethods
+      # Call within a Rails Controller to initialize HMAC authentication for the controller.
+      #
+      # * +credentials+ must be a hash that indexes secrets by their access key id.
+      # * +options+ supports the following arguments:
+      #   * +failure_message+: The text to use when authentication fails.
+      #   * +only+: A list off actions to protect.
+      #   * +except+: A list of actions to not protect.
+      #   * +hmac+: Options for HMAC creation. See AuthHMAC#initialize for options.
+      #
+      def with_auth_hmac(credentials, options = {})
+        unless credentials.nil?
+          self.credentials = credentials
+          self.authhmac_failure_message = (options.delete(:failure_message) or "HMAC Authentication failed")
+          self.authhmac = AuthHMAC.new(self.credentials, options.delete(:hmac))
+          before_filter(:hmac_login_required, options)
+        else
+          $stderr.puts("with_auth_hmac called with nil credentials - authentication will be skipped")
+        end
+      end
+    end
+
+    module InstanceMethods # :nodoc:
+      def hmac_login_required
+        unless hmac_authenticated?
+          response.headers['WWW-Authenticate'] = 'AuthHMAC'
+          render :text => self.class.authhmac_failure_message, :status => :unauthorized
+        end
+      end
+
+      def hmac_authenticated?
+        self.class.authhmac.nil? ? true : self.class.authhmac.authenticated?(request)
+      end
+    end
+
+    unless defined?(ActionController)
+      begin
+        require 'rubygems'
+        gem 'actionpack'
+        gem 'activesupport'
+        require 'action_controller'
+        require 'active_support'
+      rescue
+        nil
+      end
+    end
+
+    if defined?(ActionController::Base)
+      ActionController::Base.class_eval do
+        class_inheritable_accessor :authhmac
+        class_inheritable_accessor :credentials
+        class_inheritable_accessor :authhmac_failure_message
+      end
+
+      ActionController::Base.send(:include, ControllerFilter::InstanceMethods)
+      ActionController::Base.extend(ControllerFilter::ClassMethods)
+    end
+  end
+end

data/lib/king_hmac.rb

@@ -0,0 +1,7 @@
+require 'openssl'
+require 'base64'
+
+require File.dirname(__FILE__) + '/king_hmac/headers'
+require File.dirname(__FILE__) + '/king_hmac/cannonical_string'
+require File.dirname(__FILE__) + '/king_hmac/auth'
+require File.dirname(__FILE__) + '/king_hmac/rack/middleware'

data/spec/fixtures/credentials.yml

@@ -0,0 +1,2 @@
+"access key 1": "secret1"
+"access key 2": "secret2"

data/spec/king_hmac/king_hmac_spec.rb

@@ -0,0 +1,506 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+
+# Class for doing a custom signature
+class CustomSignature < String
+  def initialize(request)
+    self << "Custom signature string: #{request.method}"
+  end
+end
+
+def signature(value, secret)
+  digest = OpenSSL::Digest::Digest.new('sha1')
+  Base64.encode64(OpenSSL::HMAC.digest(digest, secret, value)).strip
+end
+
+describe KingHmac::Auth do
+  before(:each) do
+    @request = Net::HTTP::Put.new("/path/to/put?foo=bar&bar=foo", 
+      'content-type' => 'text/plain', 
+      'content-md5' => 'blahblah', 
+      'date' => "Thu, 10 Jul 2008 03:29:56 GMT")
+  end
+
+  describe ".canonical_string" do
+    it "should generate a canonical string using default method" do
+      KingHmac::Auth.canonical_string(@request).should == "PUT\ntext/plain\nblahblah\nThu, 10 Jul 2008 03:29:56 GMT\n/path/to/put"
+    end
+  end
+  
+  describe ".signature" do
+    it "should generate a valid signature string for a secret" do
+      KingHmac::Auth.signature(@request, 'secret').should == "71wAJM4IIu/3o6lcqx/tw7XnAJs="
+    end
+  end
+
+  describe ".sign!" do
+    before(:each) do
+      @request = Net::HTTP::Put.new("/path/to/put?foo=bar&bar=foo", 
+        'content-type' => 'text/plain', 
+        'content-md5' => 'blahblah', 
+        'date' => "Thu, 10 Jul 2008 03:29:56 GMT")
+    end
+
+    it "should sign using the key passed in as a parameter" do
+     KingHmac::Auth.sign!(@request, "my-key-id", "secret")
+     @request['Authorization'].should == "KingHmac::Auth my-key-id:71wAJM4IIu/3o6lcqx/tw7XnAJs="
+    end
+
+    it "should sign using custom service id" do
+      KingHmac::Auth.sign!(@request, "my-key-id", "secret", { :service_id => 'MyService' })
+      @request['Authorization'].should == "MyService my-key-id:71wAJM4IIu/3o6lcqx/tw7XnAJs="
+    end
+
+    it "should sign using custom signature method" do
+      options = {
+        :service_id => 'MyService',
+        :signature => CustomSignature
+      }
+      KingHmac::Auth.sign!(@request, "my-key-id", "secret", options)
+      @request['Authorization'].should == "MyService my-key-id:/L4N1v1BZSHfAYkQjsvZn696D9c="
+    end
+  end
+  
+  describe "#sign!" do
+    before(:each) do
+      @get_request = Net::HTTP::Get.new("/")
+      @put_request = Net::HTTP::Put.new("/path/to/put?foo=bar&bar=foo", 
+        'content-type' => 'text/plain', 
+        'content-md5' => 'blahblah', 
+        'date' => "Thu, 10 Jul 2008 03:29:56 GMT")
+       @store = mock('store')
+      @store.stub!(:[]).and_return("")
+      @authhmac = KingHmac::Auth.new(@store)
+    end
+
+    describe "default KingHmac::Auth with CanonicalString signature" do
+      it "should add an Authorization header" do
+        @authhmac.sign!(@get_request, 'key-id')
+        @get_request.key?("Authorization").should be_true
+      end
+      
+      it "should fetch the secret from the store" do
+        @store.should_receive(:[]).with('key-id').and_return('secret')
+        @authhmac.sign!(@get_request, 'key-id')
+      end
+      
+      it "should prefix the Authorization Header with KingHmac::Auth" do
+        @authhmac.sign!(@get_request, 'key-id')
+        @get_request['Authorization'].should match(/^KingHmac::Auth /)
+      end
+
+      it "should include the key id as the first part of the Authorization header value" do
+        @authhmac.sign!(@get_request, 'key-id')
+        @get_request['Authorization'].should match(/^KingHmac::Auth key-id:/)
+      end
+      
+      it "should include the base64 encoded HMAC signature as the last part of the header value" do
+        @authhmac.sign!(@get_request, 'key-id')
+        @get_request['Authorization'].should match(/:[A-Za-z0-9+\/]{26,28}[=]{0,2}$/)
+      end
+      
+      it "should create a complete signature" do
+        @store.should_receive(:[]).with('my-key-id').and_return('secret')
+        @authhmac.sign!(@put_request, "my-key-id")
+        @put_request['Authorization'].should == "KingHmac::Auth my-key-id:71wAJM4IIu/3o6lcqx/tw7XnAJs="
+      end
+    end
+
+    describe "custom signatures" do
+      before(:each) do
+         @options = {
+          :service_id => 'MyService',
+          :signature => CustomSignature
+        }
+        @authhmac = KingHmac::Auth.new(@store, @options)
+      end
+
+      it "should prefix the Authorization header with custom service id" do
+        @authhmac.sign!(@get_request, 'key-id')
+        @get_request['Authorization'].should match(/^MyService /)
+      end
+      
+      it "should create a complete signature using options" do
+        @store.should_receive(:[]).with('my-key-id').and_return('secret')
+        @authhmac.sign!(@put_request, "my-key-id")
+        @put_request['Authorization'].should == "MyService my-key-id:/L4N1v1BZSHfAYkQjsvZn696D9c="
+      end
+    end
+  end
+  
+  describe "authenticated?" do
+    before(:each) do
+      @credentials = load_fixture
+      @authhmac = KingHmac::Auth.new(@credentials)
+      @request = Net::HTTP::Get.new("/path/to/get?foo=bar&bar=foo", 'date' => "Thu, 10 Jul 2008 03:29:56 GMT")
+    end
+    
+    it "should return false when there is no Authorization Header" do
+      @authhmac.authenticated?(@request).should be_false
+    end
+    
+    it "should return false when the Authorization value isn't prefixed with HMAC" do
+      @request['Authorization'] = "id:secret"
+      @authhmac.authenticated?(@request).should be_false
+    end
+    
+    it "should return false when the access key id can't be found" do
+      @request['Authorization'] = 'KingHmac::Auth missing-key:blah'
+      @authhmac.authenticated?(@request).should be_false
+    end    
+    
+    it "should return false when there is no hmac" do
+      @request['Authorization'] = 'KingHmac::Auth missing-key:'
+      @authhmac.authenticated?(@request).should be_false
+    end
+    
+    it "should return false when the hmac doesn't match" do
+      @request['Authorization'] = 'KingHmac::Auth access key 1:blah'
+      @authhmac.authenticated?(@request).should be_false
+    end
+    
+    it "should return false if the request was modified after signing" do
+      @authhmac.sign!(@request, 'access key 1')
+      @request.content_type = 'text/plain'
+      @authhmac.authenticated?(@request).should be_false
+    end
+    
+    it "should return true when the hmac does match" do
+      @authhmac.sign!(@request, 'access key 1')
+      @authhmac.authenticated?(@request).should be_true
+    end
+
+    describe "custom signatures" do
+      before(:each) do
+        @options = {
+          :service_id => 'MyService',
+          :signature => CustomSignature
+        }
+      end
+
+      it "should return false for invalid service id" do
+        @authhmac.sign!(@request, 'access key 1')
+        KingHmac::Auth.new(@credentials, @options.except(:signature)).authenticated?(@request).should be_false
+      end
+
+      it "should return false for request using default CanonicalString signature" do
+        @authhmac.sign!(@request, 'access key 1')
+        KingHmac::Auth.new(@credentials, @options.except(:service_id)).authenticated?(@request).should be_false
+      end
+      
+      it "should return true when valid" do
+        @authhmac = KingHmac::Auth.new(@credentials, @options)
+        @authhmac.sign!(@request, 'access key 1')
+        @authhmac.authenticated?(@request).should be_true
+      end
+    end
+  end
+  
+  describe "#sign! with YAML credentials" do
+    before(:each) do
+      @authhmac = KingHmac::Auth.new(load_fixture)
+      @request = Net::HTTP::Get.new("/path/to/get?foo=bar&bar=foo", 'date' => "Thu, 10 Jul 2008 03:29:56 GMT")
+    end
+    
+    it "should raise an argument error if credentials are missing" do
+      lambda { @authhmac.sign!(@request, 'missing') }.should raise_error(ArgumentError)
+    end
+    
+    it "should sign with the secret" do
+      @authhmac.sign!(@request, "access key 1")
+      @request['Authorization'].should == "KingHmac::Auth access key 1:ovwO0OBERuF3/uR3aowaUCkFMiE="
+    end
+    
+    it "should sign with the other secret" do
+      @authhmac.sign!(@request, "access key 2")
+      @request['Authorization'].should == "KingHmac::Auth access key 2:vT010RQm4IZ6+UCVpK2/N0FLpLw="
+    end
+  end
+  
+  describe KingHmac::CanonicalString do
+    it "should include the http verb when it is GET" do
+      request = Net::HTTP::Get.new("/")
+      KingHmac::CanonicalString.new(request).should match(/GET/)
+    end
+    
+    it "should include the http verb when it is POST" do
+      request = Net::HTTP::Post.new("/")
+      KingHmac::CanonicalString.new(request).should match(/POST/)
+    end
+    
+    it "should include the content-type" do
+      request = Net::HTTP::Put.new("/", {'Content-Type' => 'application/xml'})
+      KingHmac::CanonicalString.new(request).should match(/application\/xml/)
+    end
+    
+    it "should include the content-type even if the case is messed up" do
+      request = Net::HTTP::Put.new("/", {'cOntent-type' => 'text/html'})
+      KingHmac::CanonicalString.new(request).should match(/text\/html/)
+    end
+    
+    it "should include the content-md5" do
+      request = Net::HTTP::Put.new("/", {'Content-MD5' => 'skwkend'})
+      KingHmac::CanonicalString.new(request).should match(/skwkend/)
+    end    
+    
+    it "should include the content-md5 even if the case is messed up" do
+      request = Net::HTTP::Put.new("/", {'content-md5' => 'adsada'})
+      KingHmac::CanonicalString.new(request).should match(/adsada/)
+    end
+    
+    it "should include the date" do
+      date = Time.now.httpdate
+      request = Net::HTTP::Put.new("/", {'Date' => date})
+      KingHmac::CanonicalString.new(request).should match(/#{date}/)
+    end
+    
+    it "should include the request path" do
+      request = Net::HTTP::Get.new("/path/to/file")
+      KingHmac::CanonicalString.new(request).should match(/\/path\/to\/file[^?]?/)
+    end
+    
+    it "should ignore the query string of the request path" do
+      request = Net::HTTP::Get.new("/other/path/to/file?query=foo")
+      KingHmac::CanonicalString.new(request).should match(/\/other\/path\/to\/file[^?]?/)
+    end
+    
+    it "should build the correct string" do
+      date = Time.now.httpdate
+      request = Net::HTTP::Put.new("/path/to/put?foo=bar&bar=foo", 
+                                    'content-type' => 'text/plain', 
+                                    'content-md5' => 'blahblah', 
+                                    'date' => date)
+      KingHmac::CanonicalString.new(request).should == "PUT\ntext/plain\nblahblah\n#{date}\n/path/to/put"
+    end
+    
+    it "should build the correct string when some elements are missing" do
+      date = Time.now.httpdate
+      request = Net::HTTP::Get.new("/path/to/get?foo=bar&bar=foo",
+                                    'date' => date)
+      KingHmac::CanonicalString.new(request).should == "GET\n\n\n#{date}\n/path/to/get"
+    end
+  end
+=begin
+  describe KingHmac::Auth::Rails::ControllerFilter do
+    class TestController < ActionController::Base
+      with_auth_hmac YAML.load(File.read(File.join(File.dirname(__FILE__), 'fixtures', 'credentials.yml'))),
+        :only => [:index]
+      
+      def index
+        render :nothing => true, :status => :ok
+      end
+      
+      def public
+        render :nothing => true, :status => :ok
+      end
+      
+      def rescue_action(e) raise(e) end
+    end
+    
+    class MessageTestController < ActionController::Base
+      with_auth_hmac YAML.load(File.read(File.join(File.dirname(__FILE__), 'fixtures', 'credentials.yml'))),
+                      :failure_message => "Stay away!", :except => :public
+      
+      def index
+        render :nothing => true, :status => :ok
+      end
+      
+      def public
+        render :nothing => true, :status => :ok
+      end
+      
+      def rescue_action(e) raise(e) end
+    end
+    
+    class NilCredentialsController < ActionController::Base
+      with_auth_hmac nil
+      before_filter :force_auth
+      
+      def index
+        render :nothing => true, :status => :ok
+      end
+      
+      def public
+        render :nothing => true, :status => :ok
+      end
+      
+      def rescue_action(e) raise(e) end
+        
+      private
+      def force_auth
+        hmac_authenticated?
+      end
+    end
+ 
+    class CustomTestController < ActionController::Base
+      with_auth_hmac YAML.load(File.read(File.join(File.dirname(__FILE__), 'fixtures', 'credentials.yml'))),
+        :failure_message => "Stay away!",
+        :except => :public,
+        :hmac => { :service_id => 'MyService', :signature => CustomSignature }
+      
+      def index
+        render :nothing => true, :status => :ok
+      end
+      
+      def public
+        render :nothing => true, :status => :ok
+      end
+      
+      def rescue_action(e) raise(e) end
+    end
+    
+    describe NilCredentialsController do
+      it "should not raise an error when credentials are nil" do
+        request = ActionController::TestRequest.new
+        request.action = 'index'
+        request.path = "/index"
+        lambda do
+          NilCredentialsController.new.process(request, ActionController::TestResponse.new).code.should == "200"
+        end.should_not raise_error
+      end
+    end
+   
+    describe TestController do
+      it "should allow a request with the proper hmac" do
+        request = ActionController::TestRequest.new
+        request.env['Authorization'] = "KingHmac::Auth access key 1:6BVEVfAyIDoI3K+WallRMnDxROQ="
+        request.env['DATE'] = "Thu, 10 Jul 2008 03:29:56 GMT"
+        request.action = 'index'
+        request.path = "/index"
+        TestController.new.process(request, ActionController::TestResponse.new).code.should == "200"
+      end
+
+      it "should reject a request with no hmac" do
+        request = ActionController::TestRequest.new
+        request.action = 'index'
+        TestController.new.process(request, ActionController::TestResponse.new).code.should == "401"
+      end
+
+      it "should reject a request with the wrong hmac" do
+        request = ActionController::TestRequest.new
+        request.action = 'index'
+        request.env['Authorization'] = "KingHmac::Auth bogus:bogus"
+        TestController.new.process(request, ActionController::TestResponse.new).code.should == "401"
+      end
+
+      it "should include a WWW-Authenticate header with the schema KingHmac::Auth" do
+        request = ActionController::TestRequest.new
+        request.action = 'index'
+        request.env['Authorization'] = "KingHmac::Auth bogus:bogus"
+        TestController.new.process(request, ActionController::TestResponse.new).headers['WWW-Authenticate'].should == "KingHmac::Auth"
+      end
+
+      it "should include a default error message" do
+        request = ActionController::TestRequest.new
+        request.action = 'index'
+        request.env['Authorization'] = "KingHmac::Auth bogus:bogus"
+        TestController.new.process(request, ActionController::TestResponse.new).body.should == "HMAC Authentication failed"
+      end
+
+      it "should allow anything to access the public action (using only)" do
+        request = ActionController::TestRequest.new
+        request.action = 'public'
+        TestController.new.process(request, ActionController::TestResponse.new).code.should == "200"
+      end
+    end
+
+    describe MessageTestController do
+      it "should reject a request with a given message" do
+        request = ActionController::TestRequest.new
+        request.action = 'index'
+        request.env['Authorization'] = "KingHmac::Auth bogus:bogus"
+        MessageTestController.new.process(request, ActionController::TestResponse.new).body.should == "Stay away!"
+      end
+
+      it "should allow anything to access the public action (using except)" do
+        request = ActionController::TestRequest.new
+        request.action = 'public'
+        MessageTestController.new.process(request, ActionController::TestResponse.new).code.should == "200"
+      end
+    end
+
+    describe CustomTestController do
+      it "should allow a request with the proper hmac" do
+        request = ActionController::TestRequest.new
+        request.env['Authorization'] = "MyService access key 1:J2W4dOrv/sGsL0C5adnZYiQ3d70="
+        request.env['DATE'] = "Thu, 10 Jul 2008 03:29:56 GMT"
+        request.action = 'index'
+        request.path = "/index"
+       CustomTestController.new.process(request, ActionController::TestResponse.new).code.should == "200"
+      end
+
+      it "should reject a request with no hmac" do
+        request = ActionController::TestRequest.new
+        request.action = 'index'
+        CustomTestController.new.process(request, ActionController::TestResponse.new).code.should == "401"
+      end
+
+      it "should reject a request with the wrong hmac" do
+        request = ActionController::TestRequest.new
+        request.action = 'index'
+        request.env['Authorization'] = "KingHmac::Auth bogus:bogus"
+        CustomTestController.new.process(request, ActionController::TestResponse.new).code.should == "401"
+      end
+
+      it "should reject a request with a given message" do
+        request = ActionController::TestRequest.new
+        request.action = 'index'
+        request.env['Authorization'] = "KingHmac::Auth bogus:bogus"
+        CustomTestController.new.process(request, ActionController::TestResponse.new).body.should == "Stay away!"
+      end
+
+      it "should allow anything to access the public action (using except)" do
+        request = ActionController::TestRequest.new
+        request.action = 'public'
+        CustomTestController.new.process(request, ActionController::TestResponse.new).code.should == "200"
+      end
+    end
+  end
+  
+  describe KingHmac::Auth::Rails::ActiveResourceExtension do
+    class TestResource < ActiveResource::Base
+      with_auth_hmac("access_id", "secret")
+      self.site = "http://localhost/"
+    end
+ 
+    class CustomTestResource < ActiveResource::Base
+      with_auth_hmac("access_id", "secret", { :service_id => 'MyService', :signature => CustomSignature })
+      self.site = "http://localhost/"
+    end
+    
+    describe TestResource do
+      it "should send requests using HMAC authentication" do
+        now = Time.parse("Thu, 10 Jul 2008 03:29:56 GMT")
+        Time.should_receive(:now).at_least(1).and_return(now)
+        ActiveResource::HttpMock.respond_to do |mock|
+          mock.get "/test_resources/1.xml", 
+            {
+              'Authorization' => 'KingHmac::Auth access_id:44dvKATf4xanDtypqEA0EFYvOgI=',
+              'Accept' => 'application/xml',
+              'Date' => "Thu, 10 Jul 2008 03:29:56 GMT"
+            },
+            { :id => "1" }.to_xml(:root => 'test_resource')
+        end
+        TestResource.find(1)
+      end
+    end
+
+    describe CustomTestResource do
+      it "should send requests using HMAC authentication" do
+        now = Time.parse("Thu, 10 Jul 2008 03:29:56 GMT")
+        Time.should_receive(:now).at_least(1).and_return(now)
+        ActiveResource::HttpMock.respond_to do |mock|
+          mock.get "/custom_test_resources/1.xml", 
+            {
+              'Authorization' => 'MyService access_id:ZwCBL2rWLOMnwRrdF7wWEdJn7yA=',
+              'Accept' => 'application/xml',
+              'Date' => "Thu, 10 Jul 2008 03:29:56 GMT"
+            },
+            { :id => "1" }.to_xml(:root => 'custom_test_resource')
+        end
+        CustomTestResource.find(1)
+      end
+    end
+  end
+=end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'spec'
+require "net/http"
+require 'time'
+require 'yaml'
+gem 'actionpack'
+gem 'activeresource'
+require 'action_controller'
+require 'action_controller/test_process'
+require 'active_resource'
+require 'active_resource/http_mock'
+
+require "#{File.dirname(__FILE__)}/../lib/king_hmac"
+
+
+
+def load_fixture
+  YAML.load(File.read(File.join(File.dirname(__FILE__), 'fixtures', 'credentials.yml')))
+end
+
+

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: king_hmac
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Georg Leciejewski
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-10 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: A Ruby Gem for authenticating HTTP requests using a HMAC
+email: gl@salesking.eu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .gitignore
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- init.rb
+- king_hmac.gemspec
+- lib/king_hmac.rb
+- lib/king_hmac/auth.rb
+- lib/king_hmac/cannonical_string.rb
+- lib/king_hmac/headers.rb
+- lib/king_hmac/rack/middleware.rb
+- lib/king_hmac/rails/active_resource.rb
+- lib/king_hmac/rails/controller.rb
+- spec/fixtures/credentials.yml
+- spec/king_hmac/king_hmac_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/salesking/king_hmac
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A Ruby Gem for authenticating HTTP requests using a HMAC
+test_files: 
+- spec/king_hmac/king_hmac_spec.rb
+- spec/spec_helper.rb