pelle-oauth 0.2.6

data/lib/oauth/helper.rb

@@ -0,0 +1,14 @@
+require 'openssl'
+require 'base64'
+module OAuth
+  module Helper
+    def escape(value)
+      CGI.escape(value.to_s).gsub("%7E", '~').gsub("+", "%20")
+    end
+    
+    def generate_key(size=32)
+      Base64.encode64(OpenSSL::Random.random_bytes(size)).gsub(/\W/,'')
+    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/request_proxy/action_controller_request.rb

@@ -0,0 +1,64 @@
+require 'rubygems'
+require 'active_support'
+require 'action_controller/request'
+require 'oauth/request_proxy/base'
+require 'uri'
+
+module OAuth::RequestProxy
+  class ActionControllerRequest < OAuth::RequestProxy::Base
+    proxies ActionController::AbstractRequest
+
+    def method
+      request.method.to_s.upcase
+    end
+
+    def uri
+      uri = URI.parse(request.protocol + request.host + request.port_string + request.path)
+      uri.query = nil
+      uri.to_s
+    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 << CGI.unescape(request.raw_post)
+        end
+      end
+      
+      params.
+        join('&').split('&').
+        reject { |kv| kv =~ /^oauth_signature=.*/}.
+        reject(&:blank?).
+        map { |p| p.split('=') }
+    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,77 @@
+require 'oauth/request_proxy'
+
+module OAuth::RequestProxy
+  class Base
+    def self.proxies(klass)
+      OAuth::RequestProxy.available_proxies[klass] = self
+    end
+
+    attr_accessor :request, :options
+
+    def initialize(request, options = {})
+      @request = request
+      @options = options
+    end
+
+    def token
+      parameters['oauth_token']
+    end
+
+    def consumer_key
+      parameters['oauth_consumer_key']
+    end
+
+    def parameters_for_signature
+      p = parameters.dup
+      p.delete("oauth_signature")
+      p.delete("oauth_token") if signature_method=='RSA-SHA1'
+      p
+    end
+
+    def nonce
+      parameters['oauth_nonce']
+    end
+
+    def timestamp
+      parameters['oauth_timestamp']
+    end
+
+    def signature_method
+      case parameters['oauth_signature_method']
+      when Array: parameters['oauth_signature_method'].first
+      else
+        parameters['oauth_signature_method']
+      end
+    end
+
+    def signature
+      parameters['oauth_signature'] || ""
+    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 '
+
+        oauth_param_string = header[6,header.length].split(/[,=]/)
+        oauth_param_string.map! { |v| unescape(v.strip) }
+        oauth_param_string.map! { |v| v =~ /^\".*\"$/ ? v[1..-2] : v }
+        oauth_params = Hash[*oauth_param_string.flatten]
+        oauth_params.reject! { |k,v| k !~ /^oauth_/ }
+
+        return oauth_params
+      end
+
+      return {}
+    end
+    
+    def unescape(value)
+      URI.unescape(value.gsub('+', '%2B'))
+    end
+    
+  end
+end

data/lib/oauth/request_proxy/net_http.rb

@@ -0,0 +1,67 @@
+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 = URI.parse(uri) unless uri.kind_of?(URI)
+        uri.query = nil
+        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,42 @@
+require 'oauth/request_proxy/base'
+require 'uri'
+require 'rack'
+
+module OAuth::RequestProxy
+  class RackRequest < OAuth::RequestProxy::Base
+    proxies Rack::Request
+    
+    def method
+      request.request_method
+    end
+    
+    def uri
+      uri = URI.parse(request.url)
+      uri.query = nil
+      uri.to_s
+    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/server.rb

@@ -0,0 +1,68 @@
+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
+      credentials=generate_credentials
+      Consumer.new( 
+        credentials[0],
+        credentials[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.rb

@@ -0,0 +1,28 @@
+module OAuth
+  module Signature
+    def self.available_methods
+      @available_methods ||= {}
+    end
+
+    def self.build(request, options = {}, &block)
+      request = OAuth::RequestProxy.proxy(request, options)
+      klass = available_methods[(request.signature_method || "").downcase]
+      raise UnknownSignatureMethod, request.signature_method unless klass
+      klass.new(request, options, &block)
+    end
+
+    def self.sign(request, options = {}, &block)
+      self.build(request, options, &block).signature
+    end
+
+    def self.verify(request, options = {}, &block)
+      self.build(request, options, &block).verify
+    end
+
+    def self.signature_base_string(request, options = {}, &block)
+      self.build(request, options, &block).signature_base_string
+    end
+
+    class UnknownSignatureMethod < Exception; end
+  end
+end

data/lib/oauth/signature/base.rb

@@ -0,0 +1,76 @@
+require 'oauth/signature'
+require 'oauth/helper'
+require 'oauth/request_proxy/base'
+require 'base64'
+
+module OAuth::Signature
+  class Base
+    include OAuth::Helper
+    
+    attr_accessor :options
+    
+    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
+
+    attr_reader :token_secret, :consumer_secret, :request
+
+    def initialize(request, options = {}, &block)
+      raise TypeError unless request.kind_of?(OAuth::RequestProxy::Base)
+      @request = request
+      @options = options
+      if block_given?
+        @token_secret, @consumer_secret = yield block.arity == 1 ? token : [token, consumer_key,nonce,request.timestamp]
+      else
+        @consumer_secret = @options[:consumer].secret
+        @token_secret = @options[:token] ? @options[:token].secret : ''
+      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
+      normalized_params = request.parameters_for_signature.sort.map { |k,v| [escape(k), escape(v)] * "=" }.join("&")
+      base = [request.method, request.uri, normalized_params]
+      sbs = base.map { |v| escape(v) }.join("&")
+    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