duse 0.0.2

data/lib/duse/client/entity.rb

@@ -0,0 +1,87 @@
+module Duse
+  module Client
+    class Entity
+      MAP = {}
+
+      def self.base_path
+        many
+      end
+
+      def self.subclasses
+        MAP.values.uniq
+      end
+
+      def self.one(key = nil)
+        MAP[key.to_s] = self if key
+        @one ||= key.to_s
+      end
+
+      def self.many(key = nil)
+        MAP[key.to_s] = self if key
+        @many ||= key.to_s
+      end
+
+      def self.attributes(*list)
+        @attributes ||= []
+
+        list.each do |name|
+          add_attribute name.to_s
+        end
+
+        @attributes
+      end
+      self.singleton_class.send :alias_method, :has, :attributes
+
+      def self.add_attribute(name)
+        dummy = self.new
+
+        attributes << name
+        define_method(name) { load_attribute(name) } unless dummy.respond_to? name
+        define_method("#{name}=") { |value| set_attribute(name, value) } unless dummy.respond_to? "#{name}="
+        define_method("#{name}?") { !!send(name) } unless dummy.respond_to? "#{name}?"
+      end
+
+      def self.id_field(key = nil)
+        @id_field = key.to_s if key
+        @id_field
+      end
+
+      attr_accessor :curry
+      attr_reader :attributes
+      alias_method :to_h, :attributes
+
+      def initialize(options = {})
+        @attributes = {}
+        options.each do |key, value|
+          self.send("#{key.to_s}=", value) if respond_to? "#{key.to_s}="
+        end
+      end
+
+      def set_attribute(name, value)
+        attributes[name.to_s] = value
+      end
+
+      def load_attribute(name)
+        reload if missing? name
+        attributes[name.to_s]
+      end
+
+      def reload
+        attributes.merge! curry.find_one(id).attributes
+      end
+
+      def save
+        fail NotImplementedError, 'Save will be the "update" action, once the api supports it'
+      end
+
+      def delete
+        curry.delete id
+      end
+
+      def missing?(name)
+        return false unless self.class.attributes.include? name
+        !attributes.key?(name)
+      end
+    end
+  end
+end

data/lib/duse/client/namespace.rb

@@ -0,0 +1,112 @@
+require 'duse/client/entity'
+require 'duse/client/session'
+
+module Duse
+  module Client
+    class Namespace < Module
+      class Curry < Module
+        attr_reader :namespace, :type
+
+        def initialize(namespace, type)
+          @namespace, @type = namespace, type
+        end
+
+        def find_one(id)
+          entity = session.find_one(type, id)
+          entity.curry = self
+          entity
+        end
+        alias_method :find, :find_one
+        alias_method :get, :find_one
+
+        def create(params)
+          entity = session.create(type, params)
+          entity.curry = self
+          entity
+        end
+
+        def update(id, params)
+          entity = session.update(type, id, params)
+          entity.curry = self
+          entity
+        end
+
+        def delete(id)
+          session.delete_one(type, id)
+        end
+
+        def find_many(params = {})
+          session.find_many(type, params).each do |e|
+            e.curry = self
+          end
+        end
+        alias_method :find_all, :find_many
+        alias_method :all, :find_all
+
+        private
+
+        def session
+          namespace.session
+        end
+
+        module User
+          def current
+            find_one 'me'
+          end
+
+          def server
+            find_one 'server'
+          end
+
+          def confirm(token)
+            session.patch('/users/confirm', { token: token })
+          end
+
+          def password_reset(token, password)
+            session.patch('/users/password', {
+              token: token,
+              password: password
+            })
+          end
+
+          def forgot_password(email)
+            session.post('/users/forgot_password', { email: self.email })
+          end
+
+          def resend_confirmation(email)
+            session.post('/users/confirm', { email: self.email })
+          end
+        end
+      end
+
+      attr_accessor :session
+
+      def initialize
+        @session = Session.new
+
+        Entity.subclasses.each do |subclass|
+          name = subclass.name[/[^:]+$/]
+          curry = Curry.new(self, subclass)
+          curry_extension = get_curry_extension(name)
+          curry.extend curry_extension if curry_extension
+          const_set(name, curry)
+        end
+      end
+
+      def get_curry_extension(name)
+        Curry.const_get(name)
+      rescue NameError
+        nil
+      end
+
+      def included(klass)
+        return if klass == Object or klass == Kernel
+        namespace = self
+        klass.define_singleton_method(:session)  { namespace.session }
+        klass.define_singleton_method(:session=) { |value| namespace.session = value }
+        klass.define_singleton_method(:config)  { session.config }
+        klass.define_singleton_method(:config=) { |value| session.config = value }
+      end
+    end
+  end
+end

data/lib/duse/client/secret.rb

@@ -0,0 +1,69 @@
+require 'duse/client/entity'
+require 'duse/encryption'
+require 'secret_sharing'
+
+module Duse
+  module Client
+    class SecretMarshaller
+      def initialize(secret, private_key)
+        @secret       = secret
+        @private_key  = private_key
+      end
+
+      def to_h
+        secret_hash = {}
+        secret_hash['title'] = @secret.title     if @secret.title
+        secret_hash['parts'] = parts_from_secret if @secret.secret_text
+        secret_hash
+      end
+
+      def parts_from_secret
+        # sliced of 18 is a result of trial & error, if it's too large then
+        # encryption will fail. Might improve with: http://stackoverflow.com/questions/11505547/how-calculate-size-of-rsa-cipher-text-using-key-size-clear-text-length
+        secret_text_in_slices_of(18).map do |secret_part|
+          shares = SecretSharing.split_secret(secret_part, 2, @secret.users.length)
+          @secret.users.each_with_index.map do |user, index|
+            share = shares[index]
+            content, signature = Duse::Encryption.encrypt(@private_key, user.public_key, share)
+            {"user_id" => user.id, "content" => content, "signature" => signature}
+          end
+        end
+      end
+
+      def secret_text_in_slices_of(piece_size)
+        encoded_secret = Encryption.encode(@secret.secret_text)
+        encoded_secret.chars.each_slice(piece_size).map(&:join)
+      end
+    end
+
+    class Secret < Entity
+      attributes :id, :title, :parts
+      has :users
+
+      attr_accessor :secret_text
+
+      id_field :id
+      one  :secret
+      many :secrets
+
+      def decrypt(private_key)
+        unless self.secret_text
+          secret_text = parts(private_key).inject('') do |result, shares|
+            result << SecretSharing.recover_secret(shares)
+          end
+          self.secret_text = Encryption.decode(secret_text)
+        end
+        self.secret_text
+      end
+
+      def parts(private_key)
+        return nil if load_attribute('parts').nil?
+        load_attribute('parts').map do |part|
+          part.map do |share|
+            Duse::Encryption.decrypt private_key, share
+          end
+        end
+      end
+    end
+  end
+end

data/lib/duse/client/session.rb

@@ -0,0 +1,128 @@
+require 'duse/client/entity'
+require 'faraday'
+require 'faraday_middleware'
+
+module Duse
+  module Client
+    class Error < StandardError; end
+    class SSLError < Error; end
+    class NotLoggedIn < Error; end
+    class NotAuthorized < Error; end
+    class NotFound < Error; end
+    class ValidationFailed < Error; end
+
+    class Session
+      attr_accessor :config
+
+      def find_one(entity, id)
+        response_body = get("/#{entity.base_path}/#{id}")
+        instance_from(entity, response_body)
+      end
+
+      def find_many(entity, params = {})
+        response_body = get("/#{entity.base_path}")
+        instances_from(entity, response_body)
+      end
+
+      def create(entity, hash)
+        response_body = post("/#{entity.base_path}", hash)
+        instance_from(entity, response_body)
+      end
+
+      def update(entity, id, hash)
+        response_body = patch("/#{entity.base_path}/#{id}", hash)
+        instance_from(entity, response_body)
+      end
+
+      def delete_one(entity, id)
+        delete("/#{entity.base_path}/#{id}")
+      end
+
+      def get(*args)
+        raw(:get, *args)
+      end
+
+      def post(*args)
+        raw(:post, *args)
+      end
+
+      def patch(*args)
+        raw(:patch, *args)
+      end
+
+      def delete(*args)
+        raw(:delete, *args)
+      end
+
+      def raw(*args)
+        process_raw_http_response raw_http_request(*args)
+      end
+
+      def process_raw_http_response(response)
+        case response.status
+        when 0             then raise SSLError, 'SSL error: could not verify peer'
+        when 200..299      then JSON.parse(response.body) rescue response.body
+        when 301, 303      then raw(:get, response.headers['Location'])
+        when 302, 307, 308 then raw(verb, response.headers['Location'])
+        when 401           then raise NotLoggedIn,      error_msg(response.body)
+        when 403           then raise NotAuthorized,    error_msg(response.body)
+        when 404           then raise NotFound,         error_msg(response.body)
+        when 422           then raise ValidationFailed, error_msg(response.body)
+        when 400..499      then raise Error,            error_msg(response.body)
+        when 500..599      then raise Error,            error_msg(response.body)
+        else raise Error, "unhandled status code #{response.status}"
+        end
+      end
+
+      def raw_http_request(*args)
+        connection.public_send(*args) do |request|
+          request.headers['Authorization'] = config.token unless config.token.nil?
+          request.headers['Accept'] = 'application/vnd.duse.1+json'
+        end
+      end
+
+      def error_msg(json)
+        result = JSON.parse(json)['message']
+        result = result.join "\n" if result.is_a? Array
+        result
+      rescue
+        json
+      end
+
+      def connection
+        fail ArgumentError, 'Uri must be set' if config.uri.nil?
+
+        @connection ||= Faraday.new url: config.uri do |faraday|
+          faraday.request  :json
+          faraday.response :json, content_type: /\bjson$/
+          faraday.adapter  *faraday_adapter
+        end
+      end
+
+      def faraday_adapter
+        Faraday.default_adapter
+      end
+
+      private
+
+      def instances_from(entity, array)
+        array.map { |e| instance_from(entity, e) }
+      end
+
+      def instance_from(entity, hash)
+        instance = entity.new
+        entity.attributes.each do |attribute|
+          if hash.has_key? attribute
+            value = hash[attribute]
+            if Entity::MAP.has_key? attribute
+              nested_entity = Entity::MAP[attribute]
+              value = hash[attribute].map { |e| instance_from(nested_entity, e) }
+            end
+            instance.public_send("#{attribute}=", value)
+          end
+        end
+        instance
+      end
+    end
+  end
+end

data/lib/duse/client/user.rb

@@ -0,0 +1,23 @@
+require 'duse/client/entity'
+require 'openssl'
+
+module Duse
+  module Client
+    class User < Entity
+      attributes :id, :username, :email, :public_key, :password
+
+      id_field :id
+      one  :user
+      many :users
+
+      def public_key
+        OpenSSL::PKey::RSA.new load_attribute 'public_key'
+      end
+
+      def public_key=(public_key)
+        public_key = public_key.to_s if public_key.is_a? OpenSSL::PKey::RSA
+        set_attribute('public_key', public_key)
+      end
+    end
+  end
+end

data/lib/duse/encryption.rb

@@ -0,0 +1,39 @@
+require 'openssl'
+require 'base64'
+
+module Duse
+  module Encryption
+    module_function
+
+    def encrypt(private_key, public_key, text)
+      encrypted = public_key.public_encrypt text.force_encoding('ascii-8bit')
+      signature = sign(private_key, encrypted)
+      [encode(encrypted), signature]
+    end
+
+    def sign(private_key, text)
+      encode(private_key.sign(digest, text))
+    end
+
+    def decrypt(private_key, text)
+      private_key.private_decrypt(decode(text)).force_encoding('utf-8')
+    end
+
+    def verify(public_key, signature, encrypted)
+      public_key.verify digest, decode(signature), decode(encrypted)
+    end
+
+    def digest
+      OpenSSL::Digest::SHA256.new
+    end
+
+    def encode(plain_text)
+      Base64.encode64(plain_text).encode('utf-8')
+    end
+
+    def decode(encoded_text)
+      Base64.decode64(encoded_text.encode('ascii-8bit')).force_encoding('utf-8')
+    end
+  end
+end
+