rack-oauth2-revibe 1.0.7

data/lib/rack/oauth2/access_token/mac/sha256_hex_verifier.rb

@@ -0,0 +1,17 @@
+module Rack
+  module OAuth2
+    class AccessToken
+      class MAC
+        class Sha256HexVerifier < Verifier
+          attr_optional :raw_body
+
+          def calculate
+            return nil unless raw_body.present?
+            
+            OpenSSL::Digest::SHA256.new.digest(raw_body).unpack('H*').first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/oauth2/access_token/mac/signature.rb

@@ -0,0 +1,34 @@
+module Rack
+  module OAuth2
+    class AccessToken
+      class MAC
+        class Signature < Verifier
+          attr_required :secret, :ts, :nonce, :method, :request_uri, :host, :port
+          attr_optional :ext, :query
+
+          def calculate
+            Rack::OAuth2::Util.base64_encode OpenSSL::HMAC.digest(
+              hash_generator,
+              secret,
+              normalized_request_string
+            )
+          end
+
+          def normalized_request_string
+            [
+              ts.to_i,
+              nonce,
+              method.to_s.upcase,
+              request_uri,
+              host,
+              port,
+              ext || '',
+              nil
+            ].join("\n")
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rack/oauth2/access_token/mac/verifier.rb

@@ -0,0 +1,44 @@
+module Rack
+  module OAuth2
+    class AccessToken
+      class MAC
+        class Verifier
+          include AttrRequired, AttrOptional
+          attr_required :algorithm
+
+          class VerificationFailed < StandardError; end
+
+          def initialize(attributes = {})
+            (required_attributes + optional_attributes).each do |key|
+              self.send :"#{key}=", attributes[key]
+            end
+            attr_missing!
+          rescue AttrRequired::AttrMissing => e
+            raise VerificationFailed.new("#{self.class.name.demodulize} Invalid: #{e.message}")
+          end
+
+          def verify!(expected)
+            if expected == self.calculate
+              :verified
+            else
+              raise VerificationFailed.new("#{self.class.name.demodulize} Invalid")
+            end
+          end
+
+          private
+
+          def hash_generator
+            case algorithm.to_s
+            when 'hmac-sha-1'
+              OpenSSL::Digest::SHA1.new
+            when 'hmac-sha-256'
+              OpenSSL::Digest::SHA256.new
+            else
+              raise 'Unsupported Algorithm'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/oauth2/client.rb

@@ -0,0 +1,139 @@
+module Rack
+  module OAuth2
+    class Client
+      include AttrRequired, AttrOptional
+      attr_required :identifier
+      attr_optional :secret, :redirect_uri, :scheme, :host, :port, :authorization_endpoint, :token_endpoint
+
+      def initialize(attributes = {})
+        (required_attributes + optional_attributes).each do |key|
+          self.send :"#{key}=", attributes[key]
+        end
+        @grant = Grant::ClientCredentials.new
+        @authorization_endpoint ||= '/oauth2/authorize'
+        @token_endpoint ||= '/oauth2/token'
+        attr_missing!
+      end
+
+      def authorization_uri(params = {})
+        params[:response_type] ||= :code
+        params[:response_type] = Array(params[:response_type]).join(' ')
+        params[:scope] = Array(params[:scope]).join(' ')
+        Util.redirect_uri absolute_uri_for(authorization_endpoint), :query, params.merge(
+          :client_id => self.identifier,
+          :redirect_uri => self.redirect_uri
+        )
+      end
+
+      def authorization_code=(code)
+        @grant = Grant::AuthorizationCode.new(
+          :code => code,
+          :redirect_uri => self.redirect_uri
+        )
+      end
+
+      def resource_owner_credentials=(credentials)
+        @grant = Grant::Password.new(
+          :username => credentials.first,
+          :password => credentials.last
+        )
+      end
+
+      def facebook_token=(token)
+        @grant = Grant::FacebookToken.new(
+          :facebook_token => token
+        )
+      end
+
+      def refresh_token=(token)
+        @grant = Grant::RefreshToken.new(
+          :refresh_token => token
+        )
+      end
+
+      def access_token!(*args)
+        headers, params = {}, @grant.as_json
+
+        # NOTE:
+        #  Using Array#estract_options! for backward compatibility.
+        #  Until v1.0.5, the first argument was 'client_auth_method' in scalar.
+        options = args.extract_options!
+        client_auth_method = args.first || options[:client_auth_method] || :basic
+
+        params[:scope] = Array(options[:scope]).join(' ') if options[:scope].present?
+
+        if secret && client_auth_method == :basic
+          cred = ["#{identifier}:#{secret}"].pack('m').tr("\n", '')
+          headers.merge!(
+            'Authorization' => "Basic #{cred}"
+          )
+        else
+          params.merge!(
+            :client_id => identifier,
+            :client_secret => secret
+          )
+        end
+        handle_response do
+          Rack::OAuth2.http_client.post(
+            absolute_uri_for(token_endpoint),
+            Util.compact_hash(params),
+            headers
+          )
+        end
+      end
+
+      private
+
+      def absolute_uri_for(endpoint)
+        _endpoint_ = Util.parse_uri endpoint
+        _endpoint_.scheme ||= self.scheme || 'https'
+        _endpoint_.host ||= self.host
+        _endpoint_.port ||= self.port
+        raise 'No Host Info' unless _endpoint_.host
+        _endpoint_.to_s
+      end
+
+      def handle_response
+        response = yield
+        case response.status
+        when 200..201
+          handle_success_response response
+        else
+          handle_error_response response
+        end
+      end
+
+      def handle_success_response(response)
+        token_hash = parse_json response.body
+        case token_hash[:token_type].try(:downcase)
+        when 'bearer'
+          AccessToken::Bearer.new(token_hash)
+        when 'mac'
+          AccessToken::MAC.new(token_hash)
+        when nil
+          AccessToken::Legacy.new(token_hash)
+        else
+          raise 'Unknown Token Type'
+        end
+      rescue MultiJson::DecodeError
+        # NOTE: Facebook support (They don't use JSON as token response)
+        AccessToken::Legacy.new Rack::Utils.parse_nested_query(response.body).with_indifferent_access
+      end
+
+      def handle_error_response(response)
+        error = parse_json response.body
+        raise Error.new(response.status, error)
+      rescue MultiJson::DecodeError
+        raise Error.new(response.status, :error => 'Unknown', :error_description => response.body)
+      end
+
+      def parse_json(raw_json)
+        # MultiJson.parse('') returns nil when using MultiJson::Adapters::JsonGem
+        MultiJson.load(raw_json).try(:with_indifferent_access) || {}
+      end
+    end
+  end
+end
+
+require 'rack/oauth2/client/error'
+require 'rack/oauth2/client/grant'

data/lib/rack/oauth2/client/error.rb

@@ -0,0 +1,14 @@
+module Rack
+  module OAuth2
+    class Client
+      class Error < StandardError
+        attr_accessor :status, :response
+        def initialize(status, response)
+          @status = status
+          @response = response
+          super response[:error_description]
+        end
+      end
+    end
+  end
+end

data/lib/rack/oauth2/client/grant.rb

@@ -0,0 +1,30 @@
+module Rack
+  module OAuth2
+    class Client
+      class Grant
+        include AttrRequired, AttrOptional
+
+        def initialize(attributes = {})
+          (required_attributes + optional_attributes).each do |key|
+            self.send "#{key}=", attributes[key]
+          end
+          attr_missing!
+        end
+
+        def as_json(options = {})
+          (required_attributes + optional_attributes).inject({
+            :grant_type => self.class.name.demodulize.underscore.to_sym
+          }) do |hash, key|
+            hash.merge! key => self.send(key)
+          end
+        end
+      end
+    end
+  end
+end
+
+require 'rack/oauth2/client/grant/authorization_code'
+require 'rack/oauth2/client/grant/password'
+require 'rack/oauth2/client/grant/facebook_token'
+require 'rack/oauth2/client/grant/client_credentials'
+require 'rack/oauth2/client/grant/refresh_token'

data/lib/rack/oauth2/client/grant/authorization_code.rb

@@ -0,0 +1,12 @@
+module Rack
+  module OAuth2
+    class Client
+      class Grant
+        class AuthorizationCode < Grant
+          attr_required :code
+          attr_optional :redirect_uri
+        end
+      end
+    end
+  end
+end

data/lib/rack/oauth2/client/grant/client_credentials.rb

@@ -0,0 +1,10 @@
+module Rack
+  module OAuth2
+    class Client
+      class Grant
+        class ClientCredentials < Grant
+        end
+      end
+    end
+  end
+end

data/lib/rack/oauth2/client/grant/facebook_token.rb

@@ -0,0 +1,12 @@
+module Rack
+  module OAuth2
+    class Client
+      class Grant
+        class FacebookToken < Grant
+          attr_required :facebook_token
+        end
+      end
+    end
+  end
+end
+

data/lib/rack/oauth2/client/grant/password.rb

@@ -0,0 +1,11 @@
+module Rack
+  module OAuth2
+    class Client
+      class Grant
+        class Password < Grant
+          attr_required :username, :password
+        end
+      end
+    end
+  end
+end

data/lib/rack/oauth2/client/grant/refresh_token.rb

@@ -0,0 +1,11 @@
+module Rack
+  module OAuth2
+    class Client
+      class Grant
+        class RefreshToken < Grant
+          attr_required :refresh_token
+        end
+      end
+    end
+  end
+end

data/lib/rack/oauth2/debugger.rb

@@ -0,0 +1,3 @@
+Dir[File.dirname(__FILE__) + '/debugger/*.rb'].each do |file|
+  require file
+end

data/lib/rack/oauth2/debugger/request_filter.rb

@@ -0,0 +1,30 @@
+module Rack
+  module OAuth2
+    module Debugger
+      class RequestFilter
+        # Callback called in HTTPClient (before sending a request)
+        # request:: HTTP::Message
+        def filter_request(request)
+          started = "======= [Rack::OAuth2] HTTP REQUEST STARTED ======="
+          log started, request.dump
+        end
+
+        # Callback called in HTTPClient (after received a response)
+        # request::  HTTP::Message
+        # response:: HTTP::Message
+        def filter_response(request, response)
+          finished = "======= [Rack::OAuth2] HTTP REQUEST FINISHED ======="
+          log '-' * 50, response.dump, finished
+        end
+
+        private
+
+        def log(*outputs)
+          outputs.each do |output|
+            OAuth2.logger.info output
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/oauth2/server.rb

@@ -0,0 +1,4 @@
+require 'rack/oauth2/server/abstract'
+require 'rack/oauth2/server/authorize'
+require 'rack/oauth2/server/token'
+require 'rack/oauth2/server/resource'

data/lib/rack/oauth2/server/abstract.rb

@@ -0,0 +1,4 @@
+require 'rack/oauth2/server/abstract/handler'
+require 'rack/oauth2/server/abstract/request'
+require 'rack/oauth2/server/abstract/response'
+require 'rack/oauth2/server/abstract/error'

data/lib/rack/oauth2/server/abstract/error.rb

@@ -0,0 +1,69 @@
+module Rack
+  module OAuth2
+    module Server
+      module Abstract
+        class Error < StandardError
+          attr_accessor :status, :error, :description, :uri, :realm
+
+          def initialize(status, error, description = nil, options = {})
+            @status      = status
+            @error       = error
+            @description = description
+            @uri         = options[:uri]
+            @realm       = options[:realm]
+            super [error, description].compact.join(' :: ')
+          end
+
+          def protocol_params
+            {
+              :error             => error,
+              :error_description => description,
+              :error_uri         => uri
+            }
+          end
+
+          def finish
+            response = Rack::Response.new
+            response.status = status
+            yield response if block_given?
+            unless response.redirect?
+              response.header['Content-Type'] = 'application/json'
+              response.write MultiJson.dump(Util.compact_hash(protocol_params))
+            end
+            response.finish
+          end
+        end
+
+        class BadRequest < Error
+          def initialize(error = :bad_request, description = nil, options = {})
+            super 400, error, description, options
+          end
+        end
+
+        class Unauthorized < Error
+          def initialize(error = :unauthorized, description = nil, options = {})
+            super 401, error, description, options
+          end
+        end
+
+        class Forbidden < Error
+          def initialize(error = :forbidden, description = nil, options = {})
+            super 403, error, description, options
+          end
+        end
+
+        class ServerError < Error
+          def initialize(error = :forbidden, description = nil, options = {})
+            super 500, error, description, options
+          end
+        end
+
+        class TemporarilyUnavailable < Error
+          def initialize(error = :forbidden, description = nil, options = {})
+            super 503, error, description, options
+          end
+        end
+      end
+    end
+  end
+end