oauth_provider 0.1.0

data/lib/oauth_provider/backends/data_mapper/user_request.rb

@@ -0,0 +1,25 @@
+module OAuthProvider
+  module Backends
+    class DataMapper
+      class UserRequest
+        include ::DataMapper::Resource
+
+        property :id, Serial
+        property :consumer_id, Integer, :nullable => false
+        property :authorized, Boolean, :default => false, :nullable => false
+        property :shared_key, String, :unique => true, :nullable => false
+        property :secret_key, String, :unique => true, :nullable => false
+
+        belongs_to :consumer , :class_name => '::OAuthProvider::Backends::DataMapper::Consumer'
+
+        def token
+          OAuthProvider::Token.new(shared_key, secret_key)
+        end
+
+        def to_oauth(backend)
+          OAuthProvider::UserRequest.new(backend, consumer.to_oauth(backend), authorized, token)
+        end
+      end
+    end
+  end
+end

data/lib/oauth_provider/backends/in_memory.rb

@@ -0,0 +1,47 @@
+module OAuthProvider
+  module Backends
+    class InMemory < Abstract
+      def initialize
+        @consumers, @user_requests, @user_accesses = [], [], []
+      end
+      attr_reader :consumers
+
+      def create_consumer(consumer)
+        raise DuplicateCallback.new(consumer) if @consumers.any? {|c| c.callback == consumer.callback}
+        @consumers << consumer
+      end
+
+      def find_consumer(shared_key)
+        @consumers.find {|x| x.shared_key == shared_key}
+      end
+
+      def destroy_consumer(consumer)
+        @consumers.delete(consumer)
+      end
+
+      def create_user_request(user_request)
+        @user_requests << user_request
+      end
+
+      def find_user_request(shared_key)
+        @user_requests.find {|x| x.shared_key == shared_key}
+      end
+
+      def save_user_request(user_request)
+        @user_requests.find {|x| x == user_request} || raise
+      end
+
+      def destroy_user_request(user_request)
+        @user_requests.delete(user_request)
+      end
+
+      def create_user_access(user_access)
+        @user_accesses << user_access
+      end
+
+      def find_user_access(shared_key)
+        @user_accesses.find {|x| x.shared_key == shared_key}
+      end
+    end
+  end
+end

data/lib/oauth_provider/backends/mysql.rb

@@ -0,0 +1,90 @@
+begin
+  require 'mysql'
+rescue LoadError
+  require 'rubygems'
+  require 'mysql'
+end
+
+module OAuthProvider
+  module Backends
+    class Mysql < OAuthProvider::Backends::Abstract
+      def initialize(host, user, password, db, port=nil)
+        @db = ::Mysql::real_connect(host, user, password, db, port)
+        @db.reconnect = true
+        @db.real_query("SET NAMES 'UTF8'")
+        # FIXME: The key column widths are perhaps not right. What is the max width of each?
+        @db.real_query("CREATE TABLE IF NOT EXISTS consumers (name CHAR(50), shared_key CHAR(43) PRIMARY KEY, secret_key CHAR(43), callback CHAR(255))")
+        @db.real_query("CREATE TABLE IF NOT EXISTS request_tokens (shared_key CHAR(22) PRIMARY KEY, secret_key CHAR(43), authorized INT, consumer_shared_key CHAR(43))")
+        @db.real_query("CREATE TABLE IF NOT EXISTS access_tokens (shared_key CHAR(22) PRIMARY KEY, secret_key CHAR(43), request_shared_key CHAR(43), consumer_shared_key CHAR(43))")
+      end
+
+      def clear!
+        @db.real_query("DROP TABLE IF EXISTS consumers")
+        @db.real_query("DROP TABLE IF EXISTS request_tokens")
+        @db.real_query("DROP TABLE IF EXISTS access_tokens")
+      end
+
+      def create_consumer(consumer)
+        # XXX: Should come up with a better way to store names than forcing the gem user to hack it in manually.
+        # Also, OAuthProvider::DuplicateCallback is a bit silly... multiple consumers with the same callback may be useful (especially since callbacks are optional.
+        @db.query("SELECT callback FROM consumers WHERE callback='#{consumer.callback}' LIMIT 1").each do
+          raise OAuthProvider::DuplicateCallback.new(consumer)
+        end
+        @db.real_query("INSERT INTO consumers (name, shared_key, secret_key, callback) " \
+                                    "VALUES ('', '#{consumer.shared_key}', '#{consumer.secret_key}', '#{consumer.callback}')")
+      end
+
+      def find_consumer(shared_key)
+        @db.query("SELECT name, callback, shared_key, secret_key FROM consumers WHERE shared_key='#{shared_key}' LIMIT 1").each do |row|
+          return OAuthProvider::Consumer.new(self, @provider, row[1], OAuthProvider::Token.new(row[2], row[3]))
+        end
+        nil
+      end
+
+      def consumers
+        rtrn = []
+        @db.query("SELECT name, callback, shared_key, secret_key FROM consumers").each do |row|
+          rtrn << OAuthProvider::Consumer.new(self, @provider, row[1], OAuthProvider::Token.new(row[2], row[3]))
+        end
+        rtrn
+      end
+
+      def destroy_consumer(consumer)
+        @db.real_query("DELETE FROM consumers WHERE shared_key='#{consumer.shared_key}' AND secret_key='#{consumer.secret_key}'")
+      end
+
+      def create_user_request(token)
+        @db.real_query("INSERT INTO request_tokens (shared_key, secret_key, authorized, consumer_shared_key) " \
+                    "VALUES ('#{token.shared_key}','#{token.secret_key}',#{token.authorized? ? 1 : 0},'#{token.consumer.shared_key}')")
+      end
+
+      def find_user_request(shared_key)
+        @db.query("SELECT shared_key, secret_key, authorized, consumer_shared_key FROM request_tokens WHERE shared_key = '#{shared_key}' LIMIT 1").each do |row|
+          return OAuthProvider::UserRequest.new(self, self.find_consumer(row[3]), row[2].to_i!=0, OAuthProvider::Token.new(row[0], row[1]))
+        end
+        raise OAuthProvider::UserRequestNotFound.new(shared_key)
+        nil
+      end
+
+      def save_user_request(user_request)
+        @db.real_query("UPDATE request_tokens SET authorized=#{user_request.authorized? ? '1' : '0'} WHERE shared_key='#{user_request.shared_key}' AND secret_key='#{user_request.secret_key}'")
+      end
+
+      def destroy_user_request(user_request)
+        @db.real_query("DELETE FROM request_tokens WHERE shared_key='#{user_request.shared_key}' AND secret_key='#{user_request.secret_key}'")
+      end
+
+      def create_user_access(token)
+        @db.real_query("INSERT INTO access_tokens (shared_key, secret_key, consumer_shared_key, request_shared_key) " \
+                    "VALUES ('#{token.shared_key}','#{token.secret_key}','#{token.consumer.shared_key}', '#{token.request_shared_key}')")
+      end
+
+      def find_user_access(shared_key)
+        @db.query("SELECT shared_key, secret_key, request_shared_key, consumer_shared_key FROM access_tokens WHERE shared_key = '#{shared_key}' LIMIT 1").each do |row|
+          return OAuthProvider::UserAccess.new(self, self.find_consumer(row[3]), row[2], OAuthProvider::Token.new(row[0], row[1]))
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/oauth_provider/backends/sequel.rb

@@ -0,0 +1,81 @@
+raise "Sequel backend is incomplete"
+
+gem 'sequel'
+require 'sequel'
+
+module OAuthProvider
+  module Backends
+    class Sequel
+      def initialize(uri)
+        @db = Sequel.connect(uri)
+      end
+
+      def save_consumer(consumer)
+        @db.execute("INSERT INTO consumers (name, shared, secret, callback) " \
+                    "VALUES ('#{consumer.name}', '#{consumer.shared}', '#{consumer.secret}', '#{consumer.callback}')")
+      end
+
+      def fetch_consumer(shared)
+        @db.execute("SELECT name, shared, secret, callback FROM consumers WHERE shared = '#{shared}' LIMIT 1") do |row|
+          return Consumer.new(self, row[0], row[1], row[2], row[3])
+        end
+        nil
+      end
+
+      def save_request_token(token)
+        @db.execute("INSERT INTO request_tokens (shared, secret, authorized, consumer_shared) " \
+                    "VALUES ('#{token.shared}','#{token.secret}',#{token.authorized ? 1 : 0},'#{token.consumer_shared}')")
+      end
+
+      def fetch_request_token(shared, consumer_shared)
+        consumer_shared = "AND consumer_shared='#{consumer_shared}'" if consumer_shared
+        @db.execute("SELECT shared, secret, authorized, consumer_shared FROM request_tokens WHERE shared = '#{shared}' #{consumer_shared} LIMIT 1") do |row|
+          consumer = fetch_consumer(row[3])
+          return RequestToken.new(consumer, row[2], row[0], row[1])
+        end
+        nil
+      end
+
+      def authorize_request_token(token)
+        @db.execute("UPDATE request_tokens SET authorized=1 WHERE shared='#{token.shared}'")
+      end
+
+      def save_access_token(token)
+        @db.execute("INSERT INTO access_tokens (shared, secret, consumer_shared, request_shared) " \
+                    "VALUES ('#{token.shared}','#{token.secret}','#{token.consumer_shared}', '#{token.request_shared}')")
+      end
+
+      def fetch_access_token(shared, consumer_shared)
+        consumer_shared = "AND consumer_shared='#{consumer_shared}'" if consumer_shared
+        @db.execute("SELECT shared, secret, request_shared, consumer_shared FROM access_tokens WHERE shared = '#{shared}' #{consumer_shared} LIMIT 1") do |row|
+          consumer = fetch_consumer(row[3])
+          return AccessToken.new(consumer, row[2], row[0], row[1])
+        end
+        nil
+      end
+
+      private
+
+      def create_tables
+        @db.execute("CREATE TABLE IF NOT EXISTS consumers (name CHAR(50), shared CHAR(32) PRIMARY KEY, secret CHAR(32), callback CHAR(255))")
+        @db.execute("CREATE TABLE IF NOT EXISTS request_tokens (shared CHAR(16) PRIMARY KEY, secret CHAR(32), authorized INT, consumer_shared CHAR(32))")
+        @db.execute("CREATE TABLE IF NOT EXISTS access_tokens (shared CHAR(16) PRIMARY KEY, secret CHAR(32), request_shared CHAR(32), consumer_shared CHAR(32))")
+        unless @db.table_exists?(:consumers)
+          @db.create_table :consumers do
+            primary_key :id
+            text :name, :shared, :secret, :callback, :unique => true, :null => false
+            index :shared
+          end
+        end
+
+        unless @db.table_exists?(:request_tokens)
+          primary_key :id
+          text :shared_key, :secret_key, :unique => true, :null => false
+          foreign_key :consumer_id, :consumers
+          index :shared_key, :consumer_id
+          end
+      end
+    end
+  end
+end
+

data/lib/oauth_provider/backends/sqlite3.rb

@@ -0,0 +1,75 @@
+require 'sqlite3'
+
+module OAuthProvider
+  module Backends
+    class Sqlite3 < Abstract
+      def initialize(path)
+        @db = SQLite3::Database.new(path)
+        @db.execute("CREATE TABLE IF NOT EXISTS consumers (name CHAR(50), shared_key CHAR(43) PRIMARY KEY, secret_key CHAR(43), callback CHAR(255))")
+        @db.execute("CREATE TABLE IF NOT EXISTS request_tokens (shared_key CHAR(22) PRIMARY KEY, secret_key CHAR(43), authorized INT, consumer_shared_key CHAR(43))")
+        @db.execute("CREATE TABLE IF NOT EXISTS access_tokens (shared_key CHAR(22) PRIMARY KEY, secret_key CHAR(43), request_shared_key CHAR(43), consumer_shared_key CHAR(43))")
+      end
+
+      def create_consumer(consumer)
+        # XXX: Should come up with a better way to store names than forcing the gem user to hack it in manually.
+        # Also, OAuthProvider::DuplicateCallback is a bit silly... multiple consumers with the same callback may be useful (especially since callbacks are optional.
+        @db.execute("SELECT callback FROM consumers WHERE callback='#{consumer.callback}'") do
+          raise OAuthProvider::DuplicateCallback.new(consumer)
+        end
+        @db.execute("INSERT INTO consumers (name, shared_key, secret_key, callback) " \
+                                    "VALUES ('', '#{consumer.shared_key}', '#{consumer.secret_key}', '#{consumer.callback}')")
+      end
+
+      def find_consumer(shared_key)
+        @db.execute("SELECT name, callback, shared_key, secret_key FROM consumers WHERE shared_key='#{shared_key}' LIMIT 1") do |row|
+          return OAuthProvider::Consumer.new(self, @provider, row[1], OAuthProvider::Token.new(row[2], row[3]))
+        end
+        nil
+      end
+
+      def consumers
+        rtrn = []
+        @db.execute("SELECT name, callback, shared_key, secret_key FROM consumers") do |row|
+          rtrn << OAuthProvider::Consumer.new(self, @provider, row[1], OAuthProvider::Token.new(row[2], row[3]))
+        end
+        rtrn
+      end
+
+      def destroy_consumer(consumer)
+        @db.execute("DELETE FROM consumers WHERE shared_key='#{consumer.shared_key}' AND secret_key='#{consumer.secret_key}'")
+      end
+
+      def create_user_request(token)
+        @db.execute("INSERT INTO request_tokens (shared_key, secret_key, authorized, consumer_shared_key) " \
+                    "VALUES ('#{token.shared_key}','#{token.secret_key}',#{token.authorized? ? 1 : 0},'#{token.consumer.shared_key}')")
+      end
+
+      def find_user_request(shared_key)
+        @db.execute("SELECT shared_key, secret_key, authorized, consumer_shared_key FROM request_tokens WHERE shared_key = '#{shared_key}' LIMIT 1") do |row|
+          return OAuthProvider::UserRequest.new(self, self.find_consumer(row[3]), row[2].to_i!=0, OAuthProvider::Token.new(row[0], row[1]))
+        end
+        nil
+      end
+
+      def save_user_request(user_request)
+        @db.execute("UPDATE request_tokens SET authorized=#{user_request.authorized? ? '1' : '0'} WHERE shared_key='#{user_request.shared_key}' AND secret_key='#{user_request.secret_key}'")
+      end
+
+      def destroy_user_request(user_request)
+        @db.execute("DELETE FROM request_tokens WHERE shared_key='#{user_request.shared_key}' AND secret_key='#{user_request.secret_key}'")
+      end
+
+      def create_user_access(token)
+        @db.execute("INSERT INTO access_tokens (shared_key, secret_key, consumer_shared_key, request_shared_key) " \
+                    "VALUES ('#{token.shared_key}','#{token.secret_key}','#{token.consumer.shared_key}', '#{token.request_shared_key}')")
+      end
+
+      def find_user_access(shared_key)
+        @db.execute("SELECT shared_key, secret_key, request_shared_key, consumer_shared_key FROM access_tokens WHERE shared_key = '#{shared_key}' LIMIT 1") do |row|
+          return OAuthProvider::UserAccess.new(self, find_consumer(row[3]), row[2], OAuthProvider::Token.new(row[0], row[1]))
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/oauth_provider/consumer.rb

@@ -0,0 +1,40 @@
+module OAuthProvider
+  class Consumer
+    def initialize(backend, provider, callback, token)
+      @backend, @provider, @callback, @token = backend, provider, callback, token
+    end
+    attr_reader :provider, :callback, :token
+
+    def find_user_request(shared_key)
+      @backend.find_user_request(shared_key) ||
+        raise(UserRequestNotFound.new(shared_key))
+    end
+
+    def destroy_user_request(shared_key)
+      @backend.destroy_user_request(shared_key) ||
+        raise(UserRequestNotFound.new(shared_key))
+    end
+
+    def find_user_access(shared_key)
+      @backend.find_user_access(shared_key) ||
+        raise(UserAccessNotFound.new(shared_key))
+    end
+
+    def issue_request(authorized = false, token = nil)
+      @backend.add_user_request(self, authorized, token || Token.generate)
+    end
+
+    def shared_key
+      @token.shared_key
+    end
+
+    def secret_key
+      @token.secret_key
+    end
+
+    def ==(consumer)
+      return false unless consumer.is_a?(Consumer)
+      [callback, token] == [consumer.callback, consumer.token]
+    end
+  end
+end

data/lib/oauth_provider/fixes.rb

@@ -0,0 +1,8 @@
+# Extend OAuth::Token to be able to create the correct query string form
+module OAuth
+  class Token
+    def to_query
+      "oauth_token=#{escape(token)}&oauth_token_secret=#{escape(secret)}"
+    end
+  end
+end

data/lib/oauth_provider/provider.rb

@@ -0,0 +1,73 @@
+module OAuthProvider
+  class Provider
+    def initialize(backend)
+      @backend = backend
+    end
+	 attr_reader :backend
+
+    # Request verification
+
+    def issue_request(request)
+      verify(request, :consumer).issue_request
+    end
+
+    def upgrade_request(request)
+      verify(request, :request).upgrade
+    end
+
+    def confirm_access(request)
+      verify(request, :access)
+    end
+
+    # Consumer
+
+    def consumers
+      @backend.consumers
+    end
+
+    def add_consumer(callback, token = nil)
+      @backend.add_consumer(self, callback, token || Token.generate)
+    end
+
+    def find_consumer(shared_key)
+      @backend.find_consumer(shared_key) ||
+        raise(ConsumerNotFound.new(shared_key))
+    end
+
+    def save_consumer(consumer)
+      @backend.save_consumer(consumer)
+    end
+
+    def destroy_consumer(consumer)
+      @backend.destroy_consumer(consumer)
+    end
+
+    private
+    def verify(request, type, &block)
+      result = nil
+
+      signature = OAuth::Signature.build(request) do |shared_key,consumer_shared_key|
+        consumer = find_consumer(consumer_shared_key)
+        case type
+        when :request
+          result = consumer.find_user_request(shared_key)
+          [result.secret_key, consumer.secret_key]
+        when :access
+          result = consumer.find_user_access(shared_key)
+          [result.secret_key, consumer.secret_key]
+        when :consumer
+          result = consumer
+          [nil, consumer.secret_key]
+        else
+          raise ArgumentError, "Type should be one of :request, :access or :consumer"
+        end
+      end
+
+      if signature.verify
+        result
+      else
+        raise VerficationFailed, "Signature verification failed: #{signature.signature} != #{signature.request.signature}"
+      end
+    end
+  end
+end