oauth-instructure 0.4.8

data/lib/oauth/request_proxy/rack_request.rb

@@ -0,0 +1,44 @@
+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
+      if request.content_type and request.content_type.to_s.downcase.start_with?("application/x-www-form-urlencoded")
+        request.POST
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/oauth/request_proxy/typhoeus_request.rb

@@ -0,0 +1,53 @@
+require 'oauth/request_proxy/base'
+require 'typhoeus'
+require 'typhoeus/request'
+require 'uri'
+require 'cgi'
+
+module OAuth::RequestProxy::Typhoeus
+  class Request < OAuth::RequestProxy::Base
+    # Proxy for signing Typhoeus::Request requests
+    # Usage example:
+    # oauth_params = {:consumer => oauth_consumer, :token => access_token}
+    # req = Typhoeus::Request.new(uri, options)
+    # oauth_helper = OAuth::Client::Helper.new(req, oauth_params.merge(:request_uri => uri))
+    # req.headers.merge!({"Authorization" => oauth_helper.header})
+    # hydra = Typhoeus::Hydra.new()
+    # hydra.queue(req)
+    # hydra.run
+    # response = req.response
+    proxies Typhoeus::Request
+
+    def method
+      request.method.to_s.upcase
+    end
+
+    def uri
+      options[:uri].to_s
+    end
+
+    def parameters
+      if options[:clobber_request]
+        options[:parameters]
+      else
+        post_parameters.merge(query_parameters).merge(options[:parameters] || {})
+      end
+    end
+
+    private
+
+    def query_parameters
+      query = URI.parse(request.url).query
+      query ? CGI.parse(query) : {}
+    end
+
+    def post_parameters
+      # Post params are only used if posting form data
+      if method == 'POST'
+        OAuth::Helper.stringify_keys(request.params || {})
+      else
+        {}
+      end
+    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.rb

@@ -0,0 +1,45 @@
+module OAuth
+  module Signature
+    # Returns a list of available signature methods
+    def self.available_methods
+      @available_methods ||= {}
+    end
+
+    # Build a signature from a +request+.
+    #
+    # Raises UnknownSignatureMethod exception if the signature method is unknown.
+    def self.build(request, options = {}, &block)
+      request = OAuth::RequestProxy.proxy(request, options)
+      klass = available_methods[
+        (request.signature_method ||
+        ((c = request.options[:consumer]) && c.options[:signature_method]) ||
+        "").downcase]
+      raise UnknownSignatureMethod, request.signature_method unless klass
+      klass.new(request, options, &block)
+    end
+
+    # Sign a +request+
+    def self.sign(request, options = {}, &block)
+      self.build(request, options, &block).signature
+    end
+
+    # Verify the signature of +request+
+    def self.verify(request, options = {}, &block)
+      self.build(request, options, &block).verify
+    end
+
+    # Create the signature base string for +request+. This string is the normalized parameter information.
+    #
+    # See Also: {OAuth core spec version 1.0, section 9.1.1}[http://oauth.net/core/1.0#rfc.section.9.1.1]
+    def self.signature_base_string(request, options = {}, &block)
+      self.build(request, options, &block).signature_base_string
+    end
+
+    # Create the body hash for a request
+    def self.body_hash(request, options = {}, &block)
+      self.build(request, options, &block).body_hash
+    end
+
+    class UnknownSignatureMethod < Exception; end
+  end
+end

data/lib/oauth/signature/base.rb

@@ -0,0 +1,110 @@
+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 = nil)
+      return @implements if signature_method.nil?
+      @implements = signature_method
+      OAuth::Signature.available_methods[@implements] = self
+    end
+
+    def self.digest_class(digest_class = nil)
+      return @digest_class if digest_class.nil?
+      @digest_class = digest_class
+    end
+
+    def self.digest_klass(digest_klass = nil)
+      return @digest_klass if digest_klass.nil?
+      @digest_klass = digest_klass
+    end
+
+    def self.hash_class(hash_class = nil)
+      return @hash_class if hash_class.nil?
+      @hash_class = hash_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
+
+    def body_hash
+      if self.class.hash_class
+        Base64.encode64(self.class.hash_class.digest(request.body || '')).chomp.gsub(/\n/,'')
+      else
+        nil # no body hash algorithm defined, so don't generate one
+      end
+    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,15 @@
+# -*- encoding: utf-8 -*-
+
+require 'oauth/signature/base'
+require 'digest/hmac'
+
+module OAuth::Signature::HMAC
+  class Base < OAuth::Signature::Base
+
+  private
+    def digest
+      self.class.digest_class Object.module_eval("::Digest::#{self.class.digest_klass}")
+      Digest::HMAC.digest(signature_base_string, secret, self.class.digest_class)
+    end
+  end
+end

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

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

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

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

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

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

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

@@ -0,0 +1,8 @@
+require 'oauth/signature/hmac/base'
+
+module OAuth::Signature::HMAC
+  class SHA2 < Base
+    implements 'hmac-sha2'
+    digest_klass '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.to_s == cmp_signature.to_s
+    end
+
+    def signature_base_string
+      secret
+    end
+
+    def secret
+      super
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require 'oauth/signature/base'
+require 'openssl'
+
+module OAuth::Signature::RSA
+  class SHA1 < OAuth::Signature::Base
+    implements 'rsa-sha1'
+    hash_class ::Digest::SHA1
+
+    def ==(cmp_signature)
+      public_key.verify(OpenSSL::Digest::SHA1.new, Base64.decode64(cmp_signature.is_a?(Array) ? cmp_signature.first : cmp_signature), signature_base_string)
+    end
+
+    def public_key
+      if consumer_secret.is_a?(String)
+        decode_public_key
+      elsif consumer_secret.is_a?(OpenSSL::X509::Certificate)
+        consumer_secret.public_key
+      else
+        consumer_secret
+      end
+    end
+
+  private
+
+    def decode_public_key
+      case consumer_secret
+      when /-----BEGIN CERTIFICATE-----/
+        OpenSSL::X509::Certificate.new( consumer_secret).public_key
+      else
+        OpenSSL::PKey::RSA.new( consumer_secret)
+      end
+    end
+
+    def digest
+      private_key = OpenSSL::PKey::RSA.new(
+        if options[:private_key_file]
+          IO.read(options[:private_key_file])
+        else
+          consumer_secret
+        end
+      )
+
+      private_key.sign(OpenSSL::Digest::SHA1.new, signature_base_string)
+    end
+  end
+end