wampproto 0.1.0

data/lib/wampproto/auth/cryptosign.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "ed25519"
+
+module Wampproto
+  module Auth
+    # generates wampcra authentication signature
+    class Cryptosign < Base
+      include Helpers
+
+      attr_reader :private_key
+      attr_accessor :channel_id
+
+      AUTH_METHOD = "cryptosign"
+
+      def initialize(private_key, authid, authextra = {})
+        @private_key = Validate.string!("Private Key", private_key)
+        super(AUTH_METHOD, authid, authextra)
+      end
+
+      def authenticate(challenge)
+        signature = self.class.create_signature(private_key, challenge.extra[:challenge], channel_id)
+        Message::Authenticate.new(signature)
+      end
+
+      class << self
+        def create_challenge
+          binary_challenge = SecureRandom.random_bytes(32)
+          binary_to_hex(binary_challenge)
+        end
+
+        def verify_challenge(signature, msg, public_key)
+          verify_key = Ed25519::VerifyKey.new(hex_to_binary(public_key))
+
+          binary_signature = hex_to_binary(signature)
+          signature = binary_signature[0, 64].to_s
+          message = binary_signature[64, 32].to_s
+          return false if message.empty? || signature.empty?
+          return false if msg != binary_to_hex(message)
+
+          verify_key.verify(signature, message)
+        end
+
+        def sign_challenge(private_key, challenge, channel_id = nil)
+          create_signature(private_key, challenge, channel_id)
+        end
+
+        def create_signature(private_key, challenge, channel_id = nil)
+          return handle_channel_binding(private_key, challenge, channel_id) if channel_id
+
+          handle_without_channel_binding(private_key, challenge)
+        end
+
+        def handle_without_channel_binding(private_key, hex_challenge)
+          key_pair = Ed25519::SigningKey.new(hex_to_binary(private_key))
+
+          binary_challenge  = hex_to_binary(hex_challenge)
+          binary_signature  = key_pair.sign(binary_challenge)
+          signature         = binary_to_hex(binary_signature)
+
+          "#{signature}#{hex_challenge}"
+        end
+
+        def handle_channel_binding(private_key, hex_challenge, channel_id)
+          key_pair = Ed25519::SigningKey.new(hex_to_binary(private_key))
+
+          channel_id              = hex_to_binary(channel_id)
+          challenge               = hex_to_binary(hex_challenge)
+          xored_challenge         = xored_strings(channel_id, challenge)
+          binary_signed_challenge = key_pair.sign(xored_challenge)
+          signature               = binary_to_hex(binary_signed_challenge)
+          hex_xored_challenge     = binary_to_hex(xored_challenge)
+          "#{signature}#{hex_xored_challenge}"
+        end
+
+        def xored_strings(channel_id, challenge_str)
+          channel_id_bytes = channel_id.bytes
+          challenge_bytes = challenge_str.bytes
+          # Added || 0 like (byte1 || 0) to make steep check happy
+          xored = channel_id_bytes.zip(challenge_bytes).map { |byte1, byte2| (byte1 || 0) ^ (byte2 || 0) }
+          xored.pack("C*")
+        end
+      end
+    end
+  end
+end

data/lib/wampproto/auth/helpers.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Wampproto
+  # Auth classes
+  module Auth
+    # Auth Helpers
+    module Helpers
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.include(ClassMethods)
+      end
+
+      # class methods
+      module ClassMethods
+        def hex_to_binary(hex_string)
+          [hex_string].pack("H*")
+        end
+
+        def binary_to_hex(binary_string)
+          binary_string.unpack1("H*")
+        end
+      end
+    end
+  end
+end

data/lib/wampproto/auth/ticket.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Wampproto
+  module Auth
+    # generates ticket authentication signature
+    class Ticket < Base
+      AUTH_METHOD = "ticket"
+      attr_reader :secret
+
+      def initialize(secret, authid, authextra = {})
+        @secret = Validate.string!("Secret", secret)
+        super(AUTH_METHOD, authid, authextra)
+      end
+
+      def authenticate(challenge)
+        signature = create_signature(challenge)
+        Message::Authenticate.new(signature)
+      end
+
+      private
+
+      def create_signature(_challenge)
+        secret
+      end
+    end
+  end
+end

data/lib/wampproto/auth.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "auth/helpers"
+require_relative "auth/base"
+require_relative "auth/anonymous"
+require_relative "auth/ticket"
+require_relative "auth/cra"
+require_relative "auth/cryptosign"
+
+module Wampproto
+  # Auth classes
+  module Auth
+  end
+end

data/lib/wampproto/broker.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Wampproto
+  # Wampproto broker implementation
+  class Broker # rubocop:disable Metrics/ClassLength
+    attr_reader :subscriptions_by_session, :subscriptions_by_topic, :id_gen, :sessions
+
+    def initialize(id_gen = IdGenerator.new)
+      @id_gen = id_gen
+      @subscriptions_by_session = {}
+      @subscriptions_by_topic = {}
+      @sessions = {}
+    end
+
+    def add_session(details)
+      session_id = details.session_id
+
+      error_message = "cannot add session twice"
+      raise KeyError, error_message if subscriptions_by_session.include?(session_id)
+
+      subscriptions_by_session[session_id] = {}
+      sessions[session_id] = details
+    end
+
+    def remove_session(session_id)
+      error_message = "cannot remove non-existing session"
+      raise KeyError, error_message unless subscriptions_by_session.include?(session_id)
+
+      subscriptions = subscriptions_by_session.delete(session_id) || {}
+      subscriptions.each do |subscription_id, topic|
+        remove_topic_subscriber(topic, subscription_id, session_id)
+      end
+      sessions.delete(session_id)
+    end
+
+    def subscription?(topic)
+      subscriptions = subscriptions_by_topic[topic]
+      return false unless subscriptions
+
+      subscriptions.any?
+    end
+
+    def receive_message(session_id, message)
+      case message
+      when Message::Subscribe then handle_subscribe(session_id, message)
+      when Message::Unsubscribe then handle_unsubscribe(session_id, message)
+      when Message::Publish then handle_publish(session_id, message)
+      else
+        raise ValueError, "message type not supported"
+      end
+    end
+
+    def handle_publish(session_id, message) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      error_message = "cannot publish, session #{session_id} doesn't exist"
+      raise ValueError, error_message unless subscriptions_by_session.include?(session_id)
+
+      subscriptions = subscriptions_by_topic.fetch(message.topic, {})
+      return if subscriptions.empty?
+
+      publication_id = id_gen.next
+
+      messages = []
+      if message.options[:acknowledge]
+        published = Message::Published.new(message.request_id, publication_id)
+        messages << MessageWithRecipient.new(published, session_id)
+      end
+      subscription_id, session_ids = subscriptions.first
+
+      event_options = event_details_for(session_id, message)
+      event = Message::Event.new(subscription_id, publication_id, event_options, *message.args, **message.kwargs)
+
+      session_ids.each_with_object(messages) do |recipient_id, list|
+        list << MessageWithRecipient.new(event, recipient_id) unless exclude?(message, session_id, recipient_id)
+      end
+    end
+
+    def handle_subscribe(session_id, message)
+      error_message = "cannot subscribe, session #{session_id} doesn't exist"
+      raise ValueError, error_message unless subscriptions_by_session.include?(session_id)
+
+      subscription_id = find_subscription_id_from(message.topic)
+      add_topic_subscriber(message.topic, subscription_id, session_id)
+      subscriptions_by_session[session_id][subscription_id] = message.topic
+
+      subscribed = Message::Subscribed.new(message.request_id, subscription_id)
+      MessageWithRecipient.new(subscribed, session_id)
+    end
+
+    def handle_unsubscribe(session_id, message) # rubocop:disable  Metrics/MethodLength, Metrics/AbcSize
+      error_message = "cannot unsubscribe, session #{session_id} doesn't exist"
+      raise ValueError, error_message unless subscriptions_by_session.include?(session_id)
+
+      subscriptions = subscriptions_by_session.fetch(session_id)
+
+      unless subscriptions.include?(message.subscription_id)
+        error = Message::Error.new(Message::Type::UNSUBSCRIBE, message.request_id, {},
+                                   "wamp.error.no_such_subscription")
+        return MessageWithRecipient.new(error, session_id)
+      end
+
+      topic = subscriptions.fetch(message.subscription_id)
+
+      remove_topic_subscriber(topic, message.subscription_id, session_id)
+      subscriptions_by_session[session_id].delete(message.subscription_id)
+
+      unsubscribed = Message::Unsubscribed.new(message.request_id)
+      MessageWithRecipient.new(unsubscribed, session_id)
+    end
+
+    private
+
+    def find_subscription_id_from(topic)
+      subscription_id, = subscriptions_by_topic.fetch(topic, {}).first
+      return subscription_id if subscription_id
+
+      id_gen.next
+    end
+
+    def remove_topic_subscriber(topic, subscription_id, session_id)
+      subscriptions = subscriptions_by_topic.fetch(topic, {})
+      return if subscriptions.empty?
+
+      if subscriptions.one? && subscriptions[subscription_id].include?(session_id)
+        return subscriptions_by_topic.delete(topic)
+      end
+
+      subscriptions_by_topic[topic][subscription_id].delete(session_id)
+    end
+
+    def add_topic_subscriber(topic, subscription_id, session_id)
+      subscriptions = subscriptions_by_topic.fetch(topic, {})
+      if subscriptions.empty?
+        subscriptions[subscription_id] = [session_id]
+      else
+        sessions = subscriptions.fetch(subscription_id, [])
+        sessions << session_id unless sessions.include?(session_id)
+        subscriptions[subscription_id] = sessions
+      end
+      subscriptions_by_topic[topic] = subscriptions
+    end
+
+    def exclude?(message, session_id, recipient_id)
+      return false if session_id != recipient_id
+
+      message.options.fetch(:exclude_me, true)
+    end
+
+    def event_details_for(session_id, message)
+      return {} unless message.options.include?(:disclose_me)
+
+      session = sessions[session_id]
+      { publisher: session_id, publisher_authid: session.authid, publisher_authrole: session.authrole }
+    end
+  end
+end

data/lib/wampproto/dealer.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Wampproto
+  # Wamprpoto Dealer handler
+  class Dealer
+    attr_reader :registrations_by_procedure, :registrations_by_session, :pending_calls, :pending_invocations, :id_gen,
+                :sessions
+
+    def initialize(id_gen = IdGenerator.new)
+      @registrations_by_session = {}
+      @registrations_by_procedure = Hash.new { |h, k| h[k] = {} }
+      @pending_calls = {}
+      @pending_invocations = {}
+      @id_gen = id_gen
+      @sessions = {}
+    end
+
+    def add_session(details)
+      session_id = details.session_id
+
+      error_message = "cannot add session twice"
+      raise KeyError, error_message if registrations_by_session.include?(session_id)
+
+      registrations_by_session[session_id] = {}
+      sessions[session_id] = details
+    end
+
+    def remove_session(session_id)
+      error_message = "cannot remove non-existing session"
+      raise KeyError, error_message unless registrations_by_session.include?(session_id)
+
+      registrations = registrations_by_session.delete(session_id) || {}
+      registrations.each do |registration_id, procedure|
+        registrations_by_procedure[procedure].delete(registration_id)
+      end
+      sessions.delete(session_id)
+    end
+
+    def registration?(procedure)
+      registrations = registrations_by_procedure[procedure]
+      return false unless registrations
+
+      registrations.any?
+    end
+
+    def receive_message(session_id, message)
+      case message
+      when Wampproto::Message::Call then handle_call(session_id, message)
+      when Message::Yield then handle_yield(session_id, message)
+      when Message::Register then handle_register(session_id, message)
+      when Message::Unregister then handle_unregister(session_id, message)
+      else
+        raise ValueError, "message type not supported"
+      end
+    end
+
+    def handle_call(session_id, message) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      registrations = registrations_by_procedure.fetch(message.procedure, {})
+      if registrations.empty?
+        error = Message::Error.new(Message::Type::CALL, message.request_id, {}, "wamp.error.no_such_procedure")
+        return MessageWithRecipient.new(error, session_id)
+      end
+
+      registration_id, callee_id = registrations.first
+
+      pending_calls[callee_id] = {} unless pending_calls.include?(callee_id)
+      pending_invocations[callee_id] = {} unless pending_invocations.include?(callee_id)
+
+      # we received call from the "caller" lets call that request_id "1"
+      # we need to send invocation message to "callee" let call that request_id "10"
+      # we need "caller" id after we have received yield so that request_id will be "10"
+      # we need to send request to "caller" to the original request_id 1
+      request_id = id_gen.next
+
+      pending_invocations[callee_id][request_id] = session_id
+
+      pending_calls[callee_id][session_id] = message.request_id
+
+      invocation = Message::Invocation.new(
+        request_id,
+        registration_id,
+        invocation_details_for(session_id, message),
+        *message.args,
+        **message.kwargs
+      )
+
+      MessageWithRecipient.new(invocation, callee_id)
+    end
+
+    def invocation_details_for(session_id, message)
+      return {} unless message.options.include?(:disclose_me)
+
+      session = sessions[session_id]
+      { caller: session_id, caller_authid: session.authid, caller_authrole: session.authrole }
+    end
+
+    def handle_yield(session_id, message)
+      calls = pending_calls.fetch(session_id, {})
+      error_message = "no pending calls for session #{session_id}"
+      raise ValueError, error_message if calls.empty?
+
+      invocations = pending_invocations[session_id]
+      caller_id = invocations.delete(message.request_id).to_i # make steep happy
+
+      request_id = calls.delete(caller_id)
+
+      result = Message::Result.new(request_id, {}, *message.args, **message.kwargs)
+      MessageWithRecipient.new(result, caller_id)
+    end
+
+    def handle_register(session_id, message)
+      error_message = "cannot register, session #{session_id} doesn't exist"
+      raise ValueError, error_message unless registrations_by_session.include?(session_id)
+
+      registration_id = id_gen.next
+      registrations_by_procedure[message.procedure][registration_id] = session_id
+      registrations_by_session[session_id][registration_id] = message.procedure
+
+      registered = Message::Registered.new(message.request_id, registration_id)
+      MessageWithRecipient.new(registered, session_id)
+    end
+
+    def handle_unregister(session_id, message) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength)
+      error_message = "cannot unregister, session #{session_id} doesn't exist"
+      raise ValueError, error_message unless registrations_by_session.include?(session_id)
+
+      registrations = registrations_by_session.fetch(session_id)
+
+      unless registrations.include?(message.registration_id)
+        error = Message::Error.new(Message::Type::UNREGISTER, message.request_id, {}, "wamp.error.no_such_registration")
+        return MessageWithRecipient.new(error, session_id)
+      end
+
+      procedure = registrations.fetch(message.registration_id)
+
+      registrations_by_procedure[procedure].delete(message.registration_id)
+      registrations_by_session[session_id].delete(message.registration_id)
+
+      unregistered = Message::Unregistered.new(message.request_id)
+      MessageWithRecipient.new(unregistered, session_id)
+    end
+  end
+end

data/lib/wampproto/id_generator.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Wampproto
+  # ID Generator
+  class IdGenerator
+    MAX_ID = 1 << 53
+
+    class << self
+      def generate_session_id
+        rand(1..MAX_ID)
+      end
+    end
+
+    def initialize
+      @id = 0
+    end
+
+    def next
+      @id = 0 if @id == MAX_ID
+      @id += 1
+    end
+  end
+end

data/lib/wampproto/joiner.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Wampproto
+  CLIENT_ROLES = {
+    caller: { features: {} },
+    callee: { features: {} },
+    publisher: { features: {} },
+    subscriber: { features: {} }
+  }.freeze
+
+  # Handle Joining part of wamp protocol
+  class Joiner
+    STATE_NONE = 0
+    STATE_HELLO_SENT = 1
+    STATE_AUTHENTICATE_SENT = 2
+    STATE_JOINED = 3
+
+    attr_reader :realm, :serializer, :authenticator
+    attr_accessor :state
+
+    def initialize(realm, serializer = Serializer::JSON, authenticator = Auth::Anonymous.new)
+      @realm = realm
+      @serializer = serializer
+      @authenticator = authenticator
+      @state = STATE_NONE
+    end
+
+    def joined?
+      @state == STATE_JOINED
+    end
+
+    def send_hello # rubocop:disable Metrics/MethodLength
+      hello = Message::Hello.new(
+        realm,
+        {
+          roles: CLIENT_ROLES,
+          authid: authenticator.authid,
+          authmethods: [authenticator.authmethod],
+          authextra: authenticator.authextra
+        }
+      )
+
+      @state = STATE_HELLO_SENT
+      serializer.serialize(hello)
+    end
+
+    def receive(data)
+      message = serializer.deserialize(data)
+      to_send = receive_message(message)
+
+      return unless to_send.instance_of?(Message::Authenticate)
+
+      serializer.serialize(to_send)
+    end
+
+    def receive_message(msg) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      case msg
+      when Message::Welcome
+        if state != STATE_HELLO_SENT && state != STATE_AUTHENTICATE_SENT
+          raise ProtocolViolation, "Received WELCOME message after session was established"
+        end
+
+        @session_details = SessionDetails.new(msg.session_id, realm, msg.authid, msg.authrole)
+        self.state = STATE_JOINED
+      when Message::Challenge
+        raise ProtocolViolation, "Received CHALLENGE message before HELLO message was sent" if state != STATE_HELLO_SENT
+
+        authenticate = authenticator.authenticate(msg)
+        self.state = STATE_AUTHENTICATE_SENT
+        authenticate
+      when Message::Abort
+        raise ValueError, "received abort"
+      else
+        raise ValueError, "received unknown message"
+      end
+    end
+  end
+end

data/lib/wampproto/message/abort.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Wampproto
+  module Message
+    # abort message
+    class Abort < Base
+      attr_reader :details, :reason, :args, :kwargs
+
+      def initialize(details, reason, *args, **kwargs)
+        super()
+        @details = Validate.hash!("Details", details)
+        @reason = Validate.string!("Reason", reason)
+        @args   = Validate.array!("Arguments", args)
+        @kwargs = Validate.hash!("Keyword Arguments", kwargs)
+      end
+
+      def marshal
+        @marshal = [Type::ABORT, details, reason]
+        @marshal << args if kwargs.any? || args.any?
+        @marshal << kwargs if kwargs.any?
+        @marshal
+      end
+
+      def self.parse(wamp_message)
+        _type, details, reason, args, kwargs = wamp_message
+        args   ||= []
+        kwargs ||= {}
+        new(details, reason, *args, **kwargs)
+      end
+    end
+  end
+end

data/lib/wampproto/message/authenticate.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Wampproto
+  module Message
+    # Wamp Authenticate message
+    class Authenticate < Base
+      attr_reader :signature, :extra
+
+      def initialize(signature, extra = {})
+        super()
+        @signature = Validate.string!("Signature", signature)
+        @extra = Validate.hash!("Extra", extra)
+      end
+
+      def marshal
+        [Type::AUTHENTICATE, signature, extra]
+      end
+
+      def self.parse(wamp_message)
+        _type, signature, extra = wamp_message
+        new(signature, extra)
+      end
+    end
+  end
+end

data/lib/wampproto/message/base.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Wampproto
+  module Message
+    # Base Interface for the Message(s)
+    class Base
+      class << self
+        def parse(msg)
+          raise NotImplementedError
+        end
+
+        def type
+          # to_s is added to satisfy RBS else they are not required
+          const = name.to_s.split("::").last.to_s.upcase
+          Wampproto::Message::Type.const_get(const)
+        end
+      end
+
+      def marshal
+        raise NotImplementedError
+      end
+
+      def type
+        # to_s is added to satisfy RBS else they are not required
+        const = self.class.name.to_s.split("::").last.to_s.upcase
+        Wampproto::Message::Type.const_get(const)
+      end
+    end
+  end
+end

data/lib/wampproto/message/call.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Wampproto
+  module Message
+    # wamp call message
+    class Call < Base
+      attr_reader :request_id, :options, :procedure, :args, :kwargs
+
+      def initialize(request_id, options, procedure, *args, **kwargs)
+        super()
+        @request_id = Validate.int!("Request Id", request_id)
+        @options    = Validate.hash!("Options", options)
+        @procedure  = Validate.string!("Procedure", procedure)
+        @args       = Validate.array!("Arguments", args)
+        @kwargs     = Validate.hash!("Keyword Arguments", kwargs)
+      end
+
+      def marshal
+        @payload = [Type::CALL, request_id, options, procedure]
+        @payload << args if kwargs.any? || args.any?
+        @payload << kwargs if kwargs.any?
+        @payload
+      end
+
+      def self.parse(wamp_message)
+        _type, request_id, options, procedure, args, kwargs = wamp_message
+        args   ||= []
+        kwargs ||= {}
+        new(request_id, options, procedure, *args, **kwargs)
+      end
+    end
+  end
+end