metavida-oauth 0.3.2

data/lib/oauth/request_proxy/action_controller_request.rb

@@ -0,0 +1,68 @@
+require 'active_support'
+require 'action_controller/request'
+require 'oauth/request_proxy/base'
+require 'uri'
+
+module OAuth::RequestProxy
+  class ActionControllerRequest < OAuth::RequestProxy::Base
+    proxies(defined?(ActionController::AbstractRequest) ? ActionController::AbstractRequest : ActionController::Request)
+
+    def method
+      request.method.to_s.upcase
+    end
+
+    def uri
+      case request
+      when ActionController::CgiRequest
+        tmp = URI.parse("#{ request.protocol }#{ request.host_with_port }#{ request.cgi.path_info }")
+        tmp.query = request.query_string unless request.query_string.blank?
+        tmp.to_s
+      else
+        request.url
+      end
+    end
+
+    def parameters
+      if options[:clobber_request]
+        options[:parameters] || {}
+      else
+        params = request_params.merge(query_params).merge(header_params)
+        params.stringify_keys! if params.respond_to?(:stringify_keys!)
+        params.merge(options[:parameters] || {})
+      end
+    end
+
+    # Override from OAuth::RequestProxy::Base to avoid roundtrip
+    # conversion to Hash or Array and thus preserve the original
+    # parameter names
+    def parameters_for_signature
+      params = []
+      params << options[:parameters].to_query if options[:parameters]
+
+      unless options[:clobber_request]
+        params << header_params.to_query
+        params << request.query_string unless request.query_string.blank?
+        if request.content_type == Mime::Type.lookup("application/x-www-form-urlencoded")
+          params << request.raw_post
+        end
+      end
+
+      params.
+        join('&').split('&').
+        reject { |kv| kv =~ /^oauth_signature=.*/}.
+        reject(&:blank?).
+        map { |p| p.split('=').map{|esc| CGI.unescape(esc)} }
+    end
+
+  protected
+
+    def query_params
+      request.query_parameters
+    end
+
+    def request_params
+      request.request_parameters
+    end
+
+  end
+end

data/lib/oauth/request_proxy/base.rb

@@ -0,0 +1,157 @@
+require 'oauth/request_proxy'
+require 'oauth/helper'
+
+module OAuth::RequestProxy
+  class Base
+    include OAuth::Helper
+
+    def self.proxies(klass)
+      OAuth::RequestProxy.available_proxies[klass] = self
+    end
+
+    attr_accessor :request, :options
+
+    def initialize(request, options = {})
+      @request = request
+      @options = options
+    end
+
+    ## OAuth parameters
+
+    def oauth_consumer_key
+      parameters['oauth_consumer_key']
+    end
+
+    def oauth_nonce
+      parameters['oauth_nonce']
+    end
+
+    def oauth_signature
+      # TODO can this be nil?
+      parameters['oauth_signature'] || ""
+    end
+
+    def oauth_signature_method
+      case parameters['oauth_signature_method']
+      when Array
+        parameters['oauth_signature_method'].first
+      else
+        parameters['oauth_signature_method']
+      end
+    end
+
+    def oauth_timestamp
+      parameters['oauth_timestamp']
+    end
+
+    def oauth_token
+      parameters['oauth_token']
+    end
+
+    def oauth_version
+      parameters["oauth_version"]
+    end
+
+    # TODO deprecate these
+    alias_method :consumer_key,     :oauth_consumer_key
+    alias_method :token,            :oauth_token
+    alias_method :nonce,            :oauth_nonce
+    alias_method :timestamp,        :oauth_timestamp
+    alias_method :signature,        :oauth_signature
+    alias_method :signature_method, :oauth_signature_method
+
+    ## Parameter accessors
+
+    def parameters
+      raise NotImplementedError, "Must be implemented by subclasses"
+    end
+
+    def parameters_for_signature
+      parameters.reject { |k,v| k == "oauth_signature" }
+    end
+
+    def oauth_parameters
+      parameters.select { |k,v| OAuth::PARAMETERS.include?(k) }.reject { |k,v| v == "" }
+    end
+
+    def non_oauth_parameters
+      parameters.reject { |k,v| OAuth::PARAMETERS.include?(k) }
+    end
+
+    # See 9.1.2 in specs
+    def normalized_uri
+      u = URI.parse(uri)
+      "#{u.scheme.downcase}://#{u.host.downcase}#{(u.scheme.downcase == 'http' && u.port != 80) || (u.scheme.downcase == 'https' && u.port != 443) ? ":#{u.port}" : ""}#{(u.path && u.path != '') ? u.path : '/'}"
+    end
+
+    # See 9.1.1. in specs Normalize Request Parameters
+    def normalized_parameters
+      normalize(parameters_for_signature)
+    end
+
+    def sign(options = {})
+      OAuth::Signature.sign(self, options)
+    end
+
+    def sign!(options = {})
+      parameters["oauth_signature"] = sign(options)
+      @signed = true
+      signature
+    end
+
+    # See 9.1 in specs
+    def signature_base_string
+      base = [method, normalized_uri, normalized_parameters]
+      base.map { |v| escape(v) }.join("&")
+    end
+
+    # Has this request been signed yet?
+    def signed?
+      @signed
+    end
+
+    # URI, including OAuth parameters
+    def signed_uri(with_oauth = true)
+      if signed?
+        if with_oauth
+          params = parameters
+        else
+          params = non_oauth_parameters
+        end
+
+        [uri, normalize(params)] * "?"
+      else
+        STDERR.puts "This request has not yet been signed!"
+      end
+    end
+
+    # Authorization header for OAuth
+    def oauth_header(options = {})
+      header_params_str = oauth_parameters.map { |k,v| "#{k}=\"#{escape(v)}\"" }.join(', ')
+
+      realm = "realm=\"#{options[:realm]}\", " if options[:realm]
+      "OAuth #{realm}#{header_params_str}"
+    end
+
+  protected
+
+    def header_params
+      %w( X-HTTP_AUTHORIZATION Authorization HTTP_AUTHORIZATION ).each do |header|
+        next unless request.env.include?(header)
+
+        header = request.env[header]
+        next unless header[0,6] == 'OAuth '
+
+        # parse the header into a Hash
+        oauth_params = OAuth::Helper.parse_header(header)
+
+        # remove non-OAuth parameters
+        oauth_params.reject! { |k,v| k !~ /^oauth_/ }
+
+        return oauth_params
+      end
+
+      return {}
+    end
+  end
+end

data/lib/oauth/request_proxy/jabber_request.rb

@@ -0,0 +1,41 @@
+require 'xmpp4r'
+require 'oauth/request_proxy/base'
+
+module OAuth
+  module RequestProxy
+    class JabberRequest < OAuth::RequestProxy::Base
+      proxies Jabber::Iq
+      proxies Jabber::Presence
+      proxies Jabber::Message
+
+      def parameters
+        return @params if @params
+
+        @params = {}
+
+        oauth = @request.get_elements('//oauth').first
+        return @params unless oauth
+
+        %w( oauth_token oauth_consumer_key oauth_signature_method oauth_signature
+            oauth_timestamp oauth_nonce oauth_version ).each do |param|
+          next unless element = oauth.first_element(param)
+          @params[param] = element.text
+        end
+
+        @params
+      end
+
+      def method
+        @request.name
+      end
+
+      def uri
+        [@request.from.strip.to_s, @request.to.strip.to_s].join("&")
+      end
+
+      def normalized_uri
+        uri
+      end
+    end
+  end
+end

data/lib/oauth/request_proxy/mock_request.rb

@@ -0,0 +1,44 @@
+require 'oauth/request_proxy/base'
+
+module OAuth
+  module RequestProxy
+    # RequestProxy for Hashes to facilitate simpler signature creation.
+    # Usage:
+    #   request = OAuth::RequestProxy.proxy \
+    #      "method" => "iq",
+    #      "uri"    => [from, to] * "&",
+    #      "parameters" => {
+    #        "oauth_consumer_key"     => oauth_consumer_key,
+    #        "oauth_token"            => oauth_token,
+    #        "oauth_signature_method" => "HMAC-SHA1"
+    #      }
+    #
+    #   signature = OAuth::Signature.sign \
+    #     request,
+    #     :consumer_secret => oauth_consumer_secret,
+    #     :token_secret    => oauth_token_secret,
+    class MockRequest < OAuth::RequestProxy::Base
+      proxies Hash
+
+      def parameters
+        @request["parameters"]
+      end
+
+      def method
+        @request["method"]
+      end
+
+      def normalized_uri
+        super
+      rescue
+        # if this is a non-standard URI, it may not parse properly
+        # in that case, assume that it's already been normalized
+        uri
+      end
+
+      def uri
+        @request["uri"]
+      end
+    end
+  end
+end

data/lib/oauth/request_proxy/net_http.rb

@@ -0,0 +1,65 @@
+require 'oauth/request_proxy/base'
+require 'net/http'
+require 'uri'
+require 'cgi'
+
+module OAuth::RequestProxy::Net
+  module HTTP
+    class HTTPRequest < OAuth::RequestProxy::Base
+      proxies ::Net::HTTPRequest
+
+      def method
+        request.method
+      end
+
+      def uri
+        uri = options[:uri]
+        uri.to_s
+      end
+
+      def parameters
+        if options[:clobber_request]
+          options[:parameters]
+        else
+          all_parameters
+        end
+      end
+
+    private
+
+      def all_parameters
+        request_params = CGI.parse(query_string)
+        if options[:parameters]
+          options[:parameters].each do |k,v|
+            if request_params.has_key?(k)
+              request_params[k] << v
+            else
+              request_params[k] = [v].flatten
+            end
+          end
+        end
+        request_params
+      end
+
+      def query_string
+        params = [ query_params, auth_header_params ]
+        is_form_urlencoded = request['Content-Type'] != nil && request['Content-Type'].downcase == 'application/x-www-form-urlencoded'
+        params << post_params if method.to_s.upcase == 'POST' && is_form_urlencoded
+        params.compact.join('&')
+      end
+
+      def query_params
+        URI.parse(request.path).query
+      end
+
+      def post_params
+        request.body
+      end
+
+      def auth_header_params
+        return nil unless request['Authorization'] && request['Authorization'][0,5] == 'OAuth'
+        auth_params = request['Authorization']
+      end
+    end
+  end
+end

data/lib/oauth/request_proxy/rack_request.rb

@@ -0,0 +1,40 @@
+require 'oauth/request_proxy/base'
+require 'uri'
+require 'rack'
+
+module OAuth::RequestProxy
+  class RackRequest < OAuth::RequestProxy::Base
+    proxies Rack::Request
+
+    def method
+      request.env["rack.methodoverride.original_method"] || request.request_method
+    end
+
+    def uri
+      request.url
+    end
+
+    def parameters
+      if options[:clobber_request]
+        options[:parameters] || {}
+      else
+        params = request_params.merge(query_params).merge(header_params)
+        params.merge(options[:parameters] || {})
+      end
+    end
+
+    def signature
+      parameters['oauth_signature']
+    end
+
+  protected
+
+    def query_params
+      request.GET
+    end
+
+    def request_params
+      request.params
+    end
+  end
+end

data/lib/oauth/request_proxy.rb

@@ -0,0 +1,24 @@
+module OAuth
+  module RequestProxy
+    def self.available_proxies #:nodoc:
+      @available_proxies ||= {}
+    end
+
+    def self.proxy(request, options = {})
+      return request if request.kind_of?(OAuth::RequestProxy::Base)
+
+      klass = available_proxies[request.class]
+
+      # Search for possible superclass matches.
+      if klass.nil?
+        request_parent = available_proxies.keys.find { |rc| request.kind_of?(rc) }
+        klass = available_proxies[request_parent]
+      end
+
+      raise UnknownRequestType, request.class.to_s unless klass
+      klass.new(request, options)
+    end
+
+    class UnknownRequestType < Exception; end
+  end
+end

data/lib/oauth/server.rb

@@ -0,0 +1,66 @@
+require 'oauth/helper'
+require 'oauth/consumer'
+
+module OAuth
+  # This is mainly used to create consumer credentials and can pretty much be ignored if you want to create your own
+  class Server
+    include OAuth::Helper
+    attr_accessor :base_url
+
+    @@server_paths = {
+      :request_token_path => "/oauth/request_token",
+      :authorize_path     => "/oauth/authorize",
+      :access_token_path  => "/oauth/access_token"
+    }
+
+    # Create a new server instance
+    def initialize(base_url, paths = {})
+      @base_url = base_url
+      @paths = @@server_paths.merge(paths)
+    end
+
+    def generate_credentials
+      [generate_key(16), generate_key]
+    end
+
+    def generate_consumer_credentials(params = {})
+      Consumer.new(*generate_credentials)
+    end
+
+    # mainly for testing purposes
+    def create_consumer
+      creds = generate_credentials
+      Consumer.new(creds[0], creds[1],
+        {
+          :site               => base_url,
+          :request_token_path => request_token_path,
+          :authorize_path     => authorize_path,
+          :access_token_path  => access_token_path
+        })
+    end
+
+    def request_token_path
+      @paths[:request_token_path]
+    end
+
+    def request_token_url
+      base_url + request_token_path
+    end
+
+    def authorize_path
+      @paths[:authorize_path]
+    end
+
+    def authorize_url
+      base_url + authorize_path
+    end
+
+    def access_token_path
+      @paths[:access_token_path]
+    end
+
+    def access_token_url
+      base_url + access_token_path
+    end
+  end
+end

data/lib/oauth/signature/base.rb

@@ -0,0 +1,91 @@
+require 'oauth/signature'
+require 'oauth/helper'
+require 'oauth/request_proxy/base'
+require 'base64'
+
+module OAuth::Signature
+  class Base
+    include OAuth::Helper
+
+    attr_accessor :options
+    attr_reader :token_secret, :consumer_secret, :request
+
+    def self.implements(signature_method)
+      OAuth::Signature.available_methods[signature_method] = self
+    end
+
+    def self.digest_class(digest_class = nil)
+      return @digest_class if digest_class.nil?
+      @digest_class = digest_class
+    end
+
+    def initialize(request, options = {}, &block)
+      raise TypeError unless request.kind_of?(OAuth::RequestProxy::Base)
+      @request = request
+      @options = options
+
+      ## consumer secret was determined beforehand
+
+      @consumer_secret = options[:consumer].secret if options[:consumer]
+
+      # presence of :consumer_secret option will override any Consumer that's provided
+      @consumer_secret = options[:consumer_secret] if options[:consumer_secret]
+
+      ## token secret was determined beforehand
+
+      @token_secret = options[:token].secret if options[:token]
+
+      # presence of :token_secret option will override any Token that's provided
+      @token_secret = options[:token_secret] if options[:token_secret]
+
+
+      # override secrets based on the values returned from the block (if any)
+      if block_given?
+        # consumer secret and token secret need to be looked up based on pieces of the request
+        secrets = yield block.arity == 1 ? request : [token, consumer_key, nonce, request.timestamp]
+        if secrets.is_a?(Array) && secrets.size == 2
+          @token_secret = secrets[0]
+          @consumer_secret = secrets[1]
+        end
+      end
+    end
+
+    def signature
+      Base64.encode64(digest).chomp.gsub(/\n/,'')
+    end
+
+    def ==(cmp_signature)
+      Base64.decode64(signature) == Base64.decode64(cmp_signature)
+    end
+
+    def verify
+      self == self.request.signature
+    end
+
+    def signature_base_string
+      request.signature_base_string
+    end
+
+  private
+
+    def token
+      request.token
+    end
+
+    def consumer_key
+      request.consumer_key
+    end
+
+    def nonce
+      request.nonce
+    end
+
+    def secret
+      "#{escape(consumer_secret)}&#{escape(token_secret)}"
+    end
+
+    def digest
+      self.class.digest_class.digest(signature_base_string)
+    end
+  end
+end

data/lib/oauth/signature/hmac/base.rb

@@ -0,0 +1,12 @@
+require 'oauth/signature/base'
+
+module OAuth::Signature::HMAC
+  class Base < OAuth::Signature::Base
+
+  private
+
+    def digest
+      self.class.digest_class.digest(secret, signature_base_string)
+    end
+  end
+end

data/lib/oauth/signature/hmac/md5.rb

@@ -0,0 +1,9 @@
+require 'oauth/signature/hmac/base'
+require 'hmac-md5'
+
+module OAuth::Signature::HMAC
+  class MD5 < Base
+    implements 'hmac-md5'
+    digest_class ::HMAC::MD5
+  end
+end

data/lib/oauth/signature/hmac/rmd160.rb

@@ -0,0 +1,9 @@
+require 'oauth/signature/hmac/base'
+require 'hmac-rmd160'
+
+module OAuth::Signature::HMAC
+  class RMD160 < Base
+    implements 'hmac-rmd160'
+    digest_class ::HMAC::RMD160
+  end
+end

data/lib/oauth/signature/hmac/sha1.rb

@@ -0,0 +1,9 @@
+require 'oauth/signature/hmac/base'
+require 'hmac-sha1'
+
+module OAuth::Signature::HMAC
+  class SHA1 < Base
+    implements 'hmac-sha1'
+    digest_class ::HMAC::SHA1
+  end
+end

data/lib/oauth/signature/hmac/sha2.rb

@@ -0,0 +1,9 @@
+require 'oauth/signature/hmac/base'
+require 'hmac-sha2'
+
+module OAuth::Signature::HMAC
+  class SHA2 < Base
+    implements 'hmac-sha2'
+    digest_class ::HMAC::SHA2
+  end
+end

data/lib/oauth/signature/md5.rb

@@ -0,0 +1,13 @@
+require 'oauth/signature/base'
+require 'digest/md5'
+
+module OAuth::Signature
+  class MD5 < Base
+    implements 'md5'
+    digest_class Digest::MD5
+
+    def signature_base_string
+      secret + super
+    end
+  end
+end

data/lib/oauth/signature/plaintext.rb

@@ -0,0 +1,23 @@
+require 'oauth/signature/base'
+
+module OAuth::Signature
+  class PLAINTEXT < Base
+    implements 'plaintext'
+
+    def signature
+      signature_base_string
+    end
+
+    def ==(cmp_signature)
+      signature == escape(cmp_signature)
+    end
+
+    def signature_base_string
+      secret
+    end
+
+    def secret
+      escape(super)
+    end
+  end
+end