meshchat 0.5.0

data/lib/meshchat/display.rb

@@ -0,0 +1,32 @@
+module MeshChat
+  module Display
+
+    module_function
+
+    # delegate :start, :add_line,
+    #   :info, :warning, :alert, :success, :chat, :whisper,
+    #   :present_message, to: :current
+
+    # TODO: Delegate doesn't work on modules?
+    def start(*args); current.start(*args); end
+    def add_line(*args); current.add_line(*args); end
+    def info(*args); current.info(*args); end
+    def warning(*args); current.warning(*args); end
+    def alert(*args); current.alert(*args); end
+    def success(*args); current.success(*args); end
+    def chat(*args); current.chat(*args); end
+    def whisper(*args); current.whisper(*args); end
+    def present_message(*args); current.present_message(*args); end
+
+    # TODO: break these out in to their own Logger class, and not
+    # on the display object
+    def fatal(*args); current.fatal(*args); end
+    def debug(*args); current.debug(*args); end
+    def error(*args); current.error(*args); end
+
+    def current
+      MeshChat::Instance.display
+    end
+
+  end
+end

data/lib/meshchat/display/base.rb

@@ -0,0 +1,53 @@
+module MeshChat
+  module Display
+    class Base
+
+      # instantiate the UI, startup the CLI
+      def start
+        fail 'overload this method'
+      end
+
+      # output a generic line of text
+      def add_line(_line)
+        fail 'overload this method'
+      end
+
+      # formatter for a whisper message
+      def whisper(_line)
+        fail 'overload this method'
+      end
+
+      # server info or other ignorable information
+      def info(_line)
+        fail 'overload this method'
+      end
+
+      # warning message that the user may or may not care about
+      def warning(_line)
+        fail 'overload this method'
+      end
+
+      # really try to get the user's attention
+      def alert(_line)
+        fail 'overload this method'
+      end
+
+      # a happy message to affirm the user something succeded
+      def success(_line)
+        fail 'overload this method'
+      end
+
+      # general chat message
+      def chat(_line)
+        fail 'overload this method'
+      end
+
+
+
+      # log a message
+      def log(_msg)
+        fail 'overload this method'
+      end
+    end
+  end
+end

data/lib/meshchat/display/manager.rb

@@ -0,0 +1,51 @@
+require 'meshchat/display/base'
+
+module MeshChat
+  module Display
+    class Manager
+
+      attr_accessor :_ui
+
+      delegate :start, to: :_ui
+      delegate :add_line, to: :_ui
+      delegate :info, to: :_ui
+      delegate :warning, to: :_ui
+      delegate :alert, to: :_ui
+      delegate :success, to: :_ui
+      delegate :chat, to: :_ui
+      delegate :whisper, to: :_ui
+
+      attr_accessor :_logger
+      delegate :fatal, to: :_logger
+      delegate :debug, to: :_logger
+      delegate :error, to: :_logger
+
+      def initialize(ui_klass)
+        self._logger = Logger.new('debug.log')
+        self._ui = ui_klass.new
+      end
+
+      def present_message(message)
+        result = message.handle
+        return unless result
+
+        case message.class.name
+        when Message::Chat.name
+          chat result
+          Notify.show(summary: message.sender_name, body: message.message)
+        when Message::Whisper.name
+          whisper result
+          Notify.show(summary: message.sender_name, body: message.message)
+        when Message::PingReply.name, Message::Ping.name
+          info result
+        when Message::NodeList.name,
+             Message::NodeListDiff.name,
+             Message::NodeListHash.name
+          # display nothing
+        else
+          add_line result
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/encryption.rb

@@ -0,0 +1,27 @@
+require 'meshchat/encryption/aes_rsa'
+require 'meshchat/encryption/passthrough'
+
+module MeshChat
+  module Encryption
+    module_function
+
+    DEFAULT_ENCRYPTOR = AES_RSA
+
+    def encryptor=(klass)
+      @current_encryptor = klass
+    end
+
+    def current_encryptor
+      @current_encryptor || DEFAULT_ENCRYPTOR
+    end
+
+    def decrypt(*args)
+      current_encryptor.decrypt(*args)
+    end
+
+    def encrypt(*args)
+      current_encryptor.encrypt(*args)
+    end
+
+  end
+end

data/lib/meshchat/encryption/aes_rsa.rb

@@ -0,0 +1,65 @@
+module MeshChat
+  module Encryption
+    # Using AES266-CBC with RSA
+    #
+    # Docs on AES
+    # http://ruby-doc.org/stdlib-2.0.0/libdoc/openssl/rdoc/OpenSSL/Cipher.html
+    module AES_RSA
+      module_function
+
+      # Use Cipher Block Chaining
+      # https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Cipher_Block_Chaining_.28CBC.29
+      AES_MODE = :CBC
+
+      # 1. Generate random AES key to encrypt message
+      # 2. Use Public Key to encrypt AES Key
+      # 3. Prepend encrypted AES key to the encrypted message
+      #
+      # Output message format will look like the following:
+      #
+      #  {RSA Encrypted AES Key}{RSA Encrypted IV}{AES Encrypted Message}
+      def encrypt(msg, public_key)
+        # 1
+        cipher = OpenSSL::Cipher::AES256.new(AES_MODE)
+        cipher.encrypt
+        aes_key = cipher.random_key
+        aes_iv = cipher.random_iv
+        aes_encrypted_message = cipher.update(msg)
+        # pad, because of how CBC works
+        padding = cipher.final
+        encrypted = aes_encrypted_message + padding
+
+        # 2
+        rsa_encryptor = OpenSSL::PKey::RSA.new public_key
+        rsa_encrypted_aes_key = rsa_encryptor.public_encrypt(aes_key)
+        rsa_encrypted_aes_iv = rsa_encryptor.public_encrypt(aes_iv)
+
+        # 3
+        rsa_encrypted_aes_key + rsa_encrypted_aes_iv + encrypted
+      end
+
+      # 1. Split the string in to the AES key and the encrypted message
+      # 2. Decrypt the AES key using the private key
+      # 3. Decrypt the message using the AES key
+      def decrypt(msg, private_key)
+        # 1
+        rsa_encrypted_aes_key = msg[0..255] # 256 bits
+        rsa_encrypted_aes_iv = msg[256..511] # next 256 bits
+        aes_encrypted_message = msg[512..msg.length]
+
+        # 2
+        rsa_decryptor = OpenSSL::PKey::RSA.new private_key
+        aes_key = rsa_decryptor.private_decrypt rsa_encrypted_aes_key
+        aes_iv = rsa_decryptor.private_decrypt rsa_encrypted_aes_iv
+
+        # 3
+        decipher = OpenSSL::Cipher::AES256.new(AES_MODE)
+        decipher.decrypt
+        decipher.key = aes_key
+        decipher.iv = aes_iv
+
+        decipher.update(aes_encrypted_message) + decipher.final
+      end
+    end
+  end
+end

data/lib/meshchat/encryption/passthrough.rb

@@ -0,0 +1,17 @@
+module MeshChat
+  module Encryption
+    # This should normally be for testing
+    #
+    # It just retuns the message that is asked to be encrypted
+    module Passthrough
+      module_function
+      def encrypt(msg, *args)
+        msg
+      end
+
+      def decrypt(msg, *args)
+        msg
+      end
+    end
+  end
+end

data/lib/meshchat/instance.rb

@@ -0,0 +1,34 @@
+module MeshChat
+  class Instance
+    attr_accessor :client_name, :client_version, :display
+
+    class << self
+      delegate :client_name, :client_version, :display,
+        to: :instance
+
+      def start(options)
+        # calling instance to get things going
+        @instance = new(options)
+        @instance.start_ui(options[:display], options[:on_display_start])
+      end
+
+      def instance
+        @instance
+      end
+    end
+
+    def initialize(options = {})
+      self.client_name = options[:client_name] || MeshChat::NAME
+      self.client_version = options[:client_version] || MeshChat::VERSION
+    end
+
+    # @param [class] klass should be something that implements Display::Base
+    # @param [Proc] proc what to do when starting the UI
+    def start_ui(klass, on_display_start)
+      self.display = Display::Manager.new(klass)
+      display.start do
+        on_display_start.call if on_display_start
+      end
+    end
+  end
+end

data/lib/meshchat/message.rb

@@ -0,0 +1,38 @@
+require 'meshchat/message/base'
+require 'meshchat/message/chat'
+require 'meshchat/message/ping'
+require 'meshchat/message/ping_reply'
+require 'meshchat/message/disconnection'
+require 'meshchat/message/whisper'
+require 'meshchat/message/relay'
+require 'meshchat/message/node_list'
+require 'meshchat/message/node_list_diff'
+require 'meshchat/message/node_list_hash'
+
+module MeshChat
+  module Message
+    CHAT = 'chat'
+    PING = 'ping'
+    PING_REPLY = 'pingreply'
+    WHISPER = 'whisper'
+    RELAY = 'relay'
+    DISCONNECTION = 'disconnection'
+
+    NODE_LIST = 'nodelist'
+    NODE_LIST_HASH = 'nodelisthash'
+    NODE_LIST_DIFF = 'nodelistdiff'
+
+    TYPES = {
+      CHAT => Chat,
+      WHISPER => Whisper,
+      DISCONNECTION => Disconnection,
+      PING => Ping,
+      PING_REPLY => PingReply,
+      NODE_LIST => NodeList,
+      NODE_LIST_DIFF => NodeListDiff,
+      NODE_LIST_HASH => NodeListHash
+    }
+
+
+  end
+end

data/lib/meshchat/message/base.rb

@@ -0,0 +1,93 @@
+module MeshChat
+  module Message
+    #
+    # NOTE:
+    #  #display: shows the message
+    #            should be used locally, before *sending* a message
+    #  #handle: processing logic for the message
+    #           should be used when receiving a message, and there
+    #           needs to be a response right away
+    #  #respond: where the actual logic for the response goes
+    class Base
+      attr_accessor :payload, :time_recieved,
+        :message, :sender_name, :sender_location, :sender_uid
+
+      # @param [String] message
+      # @param [String] name_of_sender
+      # @param [String] location the location of the sender
+      # @param [Hash] payload optionally overrides the default payload
+      def initialize(
+        message: '',
+        sender_name: '',
+        sender_location: '',
+        sender_uid: '',
+        time_recieved: nil,
+        payload: nil)
+
+        @payload = payload.presence
+
+        # TODO: find a more elegant way to represent this
+        self.message = message.presence || @payload.try(:[], 'message')
+        self.sender_name = sender_name.presence || @payload.try(:[], 'sender').try(:[], 'alias') || Settings['alias']
+        self.sender_location = sender_location.presence || @payload.try(:[], 'sender').try(:[], 'location') || Settings.location
+        self.sender_uid = sender_uid.presence || @payload.try(:[], 'sender').try(:[], 'uid') || Settings['uid']
+        self.time_recieved = time_recieved.presence || Time.now
+
+      end
+
+      def payload
+        @payload ||= {
+          'type' => type,
+          'message' => message,
+          'client' => client,
+          'client_version' => client_version,
+          'time_sent' => time_recieved || Time.now.to_s,
+          'sender' => {
+            'alias' => sender_name,
+            'location' => sender_location,
+            'uid' => sender_uid
+          }
+        }
+      end
+
+      def type
+        @type ||= TYPES.invert[self.class]
+      end
+
+      def client
+        MeshChat.name
+      end
+
+      def client_version
+        MeshChat.version
+      end
+
+      # shows the message
+      # should be used locally, before *sending* a message
+      def display
+        message
+      end
+
+      # processing logic for the message
+      # should be used when receiving a message, and there
+      # needs to be a response right away.
+      # this may call display, if the response is always to be displayed
+      def handle
+        display
+      end
+
+      # Most message types aren't going to need to have an
+      # immediate response.
+      #
+      def respond
+        return
+      end
+
+      # this message should be called immediately
+      # before sending to the whomever
+      def render
+        payload.to_json
+      end
+    end
+  end
+end

data/lib/meshchat/message/chat.rb

@@ -0,0 +1,14 @@
+module MeshChat
+  module Message
+    class Chat < Base
+
+      def display
+        time_recieved = self.time_recieved.strftime('%e/%m/%y %H:%I:%M')
+        name = payload['sender']['alias']
+        message = payload['message']
+
+        "#{time_recieved} #{name} > #{message}"
+      end
+    end
+  end
+end

data/lib/meshchat/message/disconnection.rb

@@ -0,0 +1,13 @@
+module MeshChat
+  module Message
+    class Disconnection < Base
+      def display
+        location = payload['sender']['location']
+        name = payload['sender']['alias']
+        node = Node.find_by_location(location)
+        node.update(online: false) if node
+        "#{name}@#{location} has disconnected"
+      end
+    end
+  end
+end